pax_global_header00006660000000000000000000000064145770245110014520gustar00rootroot0000000000000052 comment=c0ce4997cd29fbd729705922cbdd295d8e3593f3 coq-dpdgraph-1.0-8.19/000077500000000000000000000000001457702451100143265ustar00rootroot00000000000000coq-dpdgraph-1.0-8.19/.github/000077500000000000000000000000001457702451100156665ustar00rootroot00000000000000coq-dpdgraph-1.0-8.19/.github/workflows/000077500000000000000000000000001457702451100177235ustar00rootroot00000000000000coq-dpdgraph-1.0-8.19/.github/workflows/docker-action.yml000066400000000000000000000015521457702451100231730ustar00rootroot00000000000000# This file was generated from `meta.yml`, please do not edit manually. # Follow the instructions on https://github.com/coq-community/templates to regenerate. name: Docker CI on: push: branches: - coq-master pull_request: branches: - '**' jobs: build: # the OS must be GNU/Linux to be able to use the docker-coq-action runs-on: ubuntu-latest strategy: matrix: image: - 'coqorg/coq:dev' fail-fast: false steps: - uses: actions/checkout@v2 - uses: coq-community/docker-coq-action@v1 with: opam_file: 'coq-dpdgraph.opam' custom_image: ${{ matrix.image }} export: 'OPAMWITHTEST' env: OPAMWITHTEST: 'true' # See also: # https://github.com/coq-community/docker-coq-action#readme # https://github.com/erikmd/docker-coq-github-action-demo coq-dpdgraph-1.0-8.19/.gitignore000066400000000000000000000007041457702451100163170ustar00rootroot00000000000000.depend *.annot *.cmo *.cma *.cmi *.cmt *.a *.o *.cmx *.cmxs *.cmxa *.mlg.d version.ml graphdepend.ml searchdepend.ml autom4te.cache configure Makefile Make_coq.conf .Make_coq.d config.log config.status *.aux *.glob *.mllib.d *.v.d *.vo *.vok *.vos coqthmdep dpd2dot dpdusage Make_coq CoqMakefile.conf dpd_lex.ml dpd_parse.ml dpd_parse.mli tests/*.log tests/*.ok tests/*.dot tests/*.dpd !tests/*.err.dpd tests/*.glob tests/Test.vo META.coq-dpdgraph coq-dpdgraph-1.0-8.19/CHANGES.md000066400000000000000000000044721457702451100157270ustar00rootroot00000000000000# Changelog - [03/04/2017] Move configure.in into configure.ac and rewrite it - [21/02/2017] Add the -graphname option (default: name of the input file) (from JasonGross) - [09/01/2017] Make the software work with coq 8.6 - [09/05/2016] Add dpdusage to find unused definitions (from Vadim Zaliva). - [26/02/2016] Make the software work with coq 8.5, fix the computation of axioms, constructors, and propositions, switch from a stand-alone program to a coq plugin. - [28/09/2015] Check that the GitHub version is up-to-date + minor updates in Copyrights and README. - [26/02/2014] Change the name from dpdgraph to coq-dpdgraph and start to move to GitHub. - [24/02/2014] Add missing "Declarations.force_opaque" for Coq 8.4 thanks to Yves Bertot. Working version now. - [24/02/2014] Version 0.4b : fix compilation problems with Coq 8.4, but it is not working. Published it anyway to get some help. - [24/04/2013] Version 0.3: Adaptation for Coq 8.3 + better Makefile (thanks to Julien Narboux) - [18/09/2009] Add licence and distribute as version 0.2. - [07/08/2009] Arguments for FileDependGraph don't need ``""`` anymore + module names checking and 'globalisation' (Patch from Hugo Herbelin) - [24/07/2009] Add attributes on edges - [24/07/2009] Count the number of time an object is used by another one - [24/07/2009] Hierarchical subgraphs - [24/07/2009] Add URL to coqdoc in .dot nodes for .svg export - [24/07/2009] Tests management in Makefile - [23/07/2009] Better handling of special characters in names and identification - [23/07/2009] Identification of dot graph nodes by their full COQ names instead of a number. - [23/07/2009] First locally distributed version. # History These tools are based on the function ``SearchDepend`` that Yves Bertot posted on ``Coq-Club`` at on the February 27th, 2009. I first tried to generate a graph directly from COQ, but it becomes rapidly huge and difficult to use. It appears that we need a tool to be able to filter what we really want to see. So finally, I have made a simple file generation from coq to export every useful information. The idea is to have external tools to read the information file and generate whatever we want. I think it will be easier to maintain and extend. coq-dpdgraph-1.0-8.19/LICENSE000066400000000000000000000635061457702451100153450ustar00rootroot00000000000000GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. (This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.) Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. {description} Copyright (C) {year} {fullname} This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. {signature of Ty Coon}, 1 April 1990 Ty Coon, President of Vice That's all there is to it! coq-dpdgraph-1.0-8.19/Make000066400000000000000000000001661457702451100151310ustar00rootroot00000000000000-generate-meta-for-package coq-dpdgraph -I . -R . dpdgraph searchdepend.mlg graphdepend.mlg dpdgraph.mllib dpdgraph.v coq-dpdgraph-1.0-8.19/Makefile.in000066400000000000000000000206561457702451100164040ustar00rootroot00000000000000#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # This file is part of the DpdGraph tools. # Copyright (C) 2009-2017 Anne Pacalet (Anne.Pacalet@free.fr) # and Yves Bertot (Yves.Bertot@inria.fr) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # This file is distributed under the terms of the # GNU Lesser General Public License Version 2.1 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .SUFFIXES: ECHO=@echo ECHO_CIBLE = $(ECHO) " * build $@" PRE=dpd NAME=@PACKAGE_NAME@ VERSION=@PACKAGE_VERSION@ BINDIR=@BINDIR@ DPDPLUGIN=./dpdgraph.vo DPD2DOT=./dpd2dot DPDUSAGE=./dpdusage INCLUDES = -I @OCAMLGRAPH_PATH@ all : $(DPDPLUGIN) $(DPD2DOT) $(DPDUSAGE) DISTRIBUTED = $(PRE)_compute.ml $(PRE)_dot.ml \ $(PRE)_parse.mly $(PRE)_lex.mll $(PRE)2dot.ml $(PRE)usage.ml DISTRIBUTED+=dpdgraph.v ML_COMMON = version.ml $(PRE)_compute.ml $(PRE)_dot.ml \ $(PRE)_parse.ml $(PRE)_lex.ml MLI_COMMON = version.mli $(PRE)_compute.mli $(PRE)_dot.mli $(PRE)_lex.mli ML_DPD2DOT = $(PRE)2dot.ml MLI_DPD2DOT = $(PRE)2dot.mli ML_DPDUSAGE = $(PRE)usage.ml MLI_DPDUSAGE = $(PRE)usage.mli DISTRIBUTED+=$(MLI_COMMON) $(MLI_DPD2DOT) $(MLI_DPDUSAGE) ML_ALL = $(ML_COMMON) $(ML_DPD2DOT) $(ML_DPDUSAGE) CMIS_DPD2DOT=$(MLI_COMMON:%.ml=%.cmo) $(MLI_DPD2DOT:%.ml=%.cmo) CMOS_DPD2DOT=$(ML_COMMON:%.ml=%.cmo) $(ML_DPD2DOT:%.ml=%.cmo) CMIS_DPDUSAGE=$(MLI_COMMON:%.ml=%.cmo) $(MLI_DPDUSAGE:%.ml=%.cmo) CMOS_DPDUSAGE=$(ML_COMMON:%.ml=%.cmo) $(ML_DPDUSAGE:%.ml=%.cmo) CMXS=$(ML_ALL:%.ml=%.cmx) OCAMLC=@OCAMLC@ OCAMLOPT=@OCAMLOPT@ OCAMLDEP=@OCAMLDEP@ OCAMLLEX=@OCAMLLEX@ OCAMLYACC=@OCAMLYACC@ WARN_ERR := -warn-error +a OCAMLFLAGS := -w +a $(WARN_ERR) -g -dtypes $(INCLUDES) -c OCAMLFLAGS += $(OCAML_EXTRA_OPTS) OCAMLOPTFLAGS = -c COQ_MAKEFILE=@COQ_MAKEFILE@ # COQDEP=$(OCAMLDEP) COQEXTFILES=searchdepend.mlg graphdepend.mlg GENERATED+=$(COQEXTFILES:%.mlg=%.o) $(COQEXTFILES:%.mlg=%.cmx) dpdgraph.cmxs DISTRIBUTED+=$(COQEXTFILES) dpdgraph.mllib DISTRIBUTED+=Make install : Make_coq $(MAKE) -f $< install cp dpd2dot dpdusage $(BINDIR)/ $(DPDPLUGIN) : Make_coq $(DISTRIBUTED) $(ECHO_CIBLE) $(MAKE) -f $< $@ Make_coq : Make $(ECHO_CIBLE) $(COQ_MAKEFILE) -f $< -o $@ GENERATED+= Make_coq version.ml : configure $(ECHO_CIBLE) $(ECHO) "(* This file is generated by Makefile. Do not modify. *)" > $@ $(ECHO) "let version = \""$(VERSION)"\"" >> $@ GENERATED+=version.ml $(DPD2DOT) : $(CMOS_DPD2DOT) $(CMIS_DPD2DOT) $(ECHO_CIBLE) $(OCAMLC) -g $(INCLUDES) -o $@ graph.cma $(CMOS_DPD2DOT) $(DPDUSAGE) : $(CMOS_DPDUSAGE) $(CMIS_DPDUSAGE) $(ECHO_CIBLE) $(OCAMLC) -g $(INCLUDES) -o $@ graph.cma $(CMOS_DPDUSAGE) %.cmo : %.ml $(ECHO_CIBLE) $(OCAMLC) $(OCAMLFLAGS) $< %.cmx : %.ml $(ECHO_CIBLE) $(OCAMLOPT) $(OPTPACKFLAGS) $(OCAMLOPTFLAGS) $< %.cmi : %.mli $(ECHO_CIBLE) $(OCAMLC) $(OCAMLFLAGS) $< %.ml : %.mll $(ECHO_CIBLE) $(OCAMLLEX) $< GENERATED+=$(PRE)_lex.ml %.ml : %.mly $(ECHO_CIBLE) $(OCAMLYACC) $< GENERATED+=$(PRE)_parse.ml $(PRE)_parse.mli depend: .depend .depend : $(ML_ALL) $(ECHO_CIBLE) $(OCAMLDEP) $(ML_ALL) *.mli > $@ include .depend GENERATED+=.depend #------------------------------------------------------------------------------- TESTDIR=tests TESTS_SRC=$(TESTDIR)/Morph.v $(TESTDIR)/Test.v $(TESTDIR)/Polymorph.v \ $(TESTDIR)/PrimitiveProjections.v\ $(TESTDIR)/Morph.cmd $(TESTDIR)/Test.cmd $(TESTDIR)/search.cmd \ $(TESTDIR)/Polymorph.cmd $(TESTDIR)/PrimitiveProjections.cmd TESTS_DPD=$(TESTDIR)/graph.dpd $(TESTDIR)/graph2.dpd \ $(TESTDIR)/Morph.dpd $(TESTDIR)/Morph_rw.dpd \ $(TESTDIR)/Polymorph.dpd \ $(TESTDIR)/PrimitiveProjections.dpd \ $(TESTDIR)/PrimitiveProjections2.dpd TESTS_DOT=$(TESTS_DPD:%.dpd=%.dot) TESTS_ERR_DPD=$(wildcard $(TESTDIR)/*.err.dpd) TESTS=$(TESTS_DPD) $(TESTS_DOT) $(TESTDIR)/graph.without.dot \ $(TESTDIR)/search $(TESTDIR)/graph2.dpdusage \ $(TESTS_ERR_DPD:%.dpd=%) $(TESTDIR)/file_not_found.err TESTS_LOG=$(TESTS:%=%.log) TESTS_ORACLE=$(TESTS:%=%.oracle) TESTS_OK=$(TESTS:%=%.ok) DISTRIBUTED+=$(TESTS_SRC) $(TESTS_ORACLE) .PRECIOUS : $(TESTS) $(TESTS_LOG) $(TESTS_ORACLE) .PHONY: tests test tests test : $(TESTS_OK) .PHONY: test-suite test-suite: rm -f tests.ok ($(MAKE) tests && touch tests.ok) | tee tmp.log if grep DIFFERENCES tmp.log >/dev/null 2>&1 ; then \ for i in $$(grep DIFFERENCES tmp.log | grep -o 'diff .*' | sed s'/diff //g' | sed s'/ /~/g'); do \ i="$$(echo "$$i" | sed s'/~/ /g')"; \ echo diff $$i; \ diff $$i; \ done ; \ fi if grep DIFFERENCES tmp.log >/dev/null 2>&1 ; then false ; else true ; fi rm tests.ok $(TESTDIR)/%.dpdusage.log: $(TESTDIR)/%.dpd $(DPDUSAGE) $(DPDUSAGE) $< > $@ $(TESTDIR)/file_not_found.err.log: $(DPD2DOT) $(DPD2DOT) file_not_found.err.dpd > $@ 2>&1 $(TESTDIR)/%.err.log: $(TESTDIR)/%.err.dpd $(DPD2DOT) $(DPD2DOT) $< > $@ 2>&1 %.log : % cp $< $@ %.vo : %.v coqc -q -R . dpdgraph $< %.html : %.v coqdoc $< %.svg : %.dot dot -Tsvg -o$@ $< $(TESTDIR)/Morph%.dpd : $(TESTDIR)/Morph.vo $(TESTDIR)/Morph.cmd $(DPDPLUGIN) # cd to tests to generate .dpd file there. cd $(TESTDIR); coqtop -R .. dpdgraph -I .. < Morph.cmd > /dev/null 2>&1 $(TESTDIR)/Polymorph%.dpd : $(TESTDIR)/Polymorph.vo $(TESTDIR)/Polymorph.cmd \ $(DPDPLUGIN) cd $(TESTDIR); coqtop -R .. dpdgraph -I .. < Polymorph.cmd $(TESTDIR)/graph.dpd $(TESTDIR)/graph2.dpd: \ $(TESTDIR)/Test.vo $(TESTDIR)/Test.cmd $(DPDPLUGIN) # cd to tests to generate .dpd file there. cd $(TESTDIR); coqtop -R .. dpdgraph -I .. < Test.cmd > /dev/null 2>&1 $(TESTDIR)/PrimitiveProjections.dpd $(TESTDIR)/PrimitiveProjections2.dpd: \ $(TESTDIR)/PrimitiveProjections.vo $(TESTDIR)/PrimitiveProjections.cmd $(DPDPLUGIN) # cd to tests to generate .dpd file there. cd $(TESTDIR); coqtop -R .. dpdgraph -I .. < PrimitiveProjections.cmd > /dev/null 2>&1 %.dpd : %.vo %.cmd # cd to tests to generate .dpd file there. cd $(TESTDIR); coqtop -R .. dpdgraph -I .. < $(*F).cmd > /dev/null 2>&1 $(TESTDIR)/search.log : $(TESTDIR)/Test.vo $(TESTDIR)/search.cmd $(DPDPLUGIN) cat $(TESTDIR)/search.cmd | coqtop -R . dpdgraph -I . 2> /dev/null \ | sed -e 's/Welcome to Coq.*/Welcome to Coq/' > $@ %.dot : %.dpd $(DPD2DOT) $(DPD2DOT) $< > /dev/null %.without.dot : %.dpd $(DPD2DOT) $(DPD2DOT) -without-defs -o $@ $< > /dev/null %.zgr : %.dot zgrviewer $< %.ok : %.log %.oracle $(ECHO_CIBLE) @if diff $*.oracle $*.log > /dev/null ; then \ echo "Bravo... Test Ok" ; \ touch $@ ; \ else \ echo "DIFFERENCES : diff $*.oracle $*.log" ; \ echo "To force a new execution of the test:" ; \ echo " rm $*.log ; make $*.ok"; \ echo "To accept the results: " ; \ echo " cp $*.log $*.oracle" ; \ rm -f $@ ; \ fi # oracle is updated by user, but one is needed the first time %.oracle : $(ECHO_CIBLE) "[WARNING : automatic generation of $@]" $(MAKE) $*.log cp $*.log $*.oracle #------------------------------------------------------------------------------- DISTRIBUTED+=Makefile LICENSE README.md configure Makefile.in distrib : $(NAME)-$(VERSION).tgz %.tgz : clean $(ECHO_CIBLE) rm -rf $* $@ mkdir $* cp --parents $(DISTRIBUTED) $* tar zcvf $@ $* rm -rf $* $(ECHO) "Don't forget to copy README.md and $@ on the server if needed" #------------------------------------------------------------------------------- # Configuration Makefile: Makefile.in config.status $(ECHO_CIBLE) ./config.status $@ config.status: configure ./config.status --recheck #------------------------------------------------------------------------------- clean_coq : Make_coq $(MAKE) -f $< clean clean_test : rm -f $(TESTS) $(TESTS_LOG) $(TESTS_OK) rm -f $(TESTDIR)/Test.vo $(TESTDIR)/Test.glob rm -f $(TESTDIR)/Morph.vo $(TESTDIR)/Morph.glob rm -f $(TESTDIR)/Polymorph.vo $(TESTDIR)/Polymorph.glob rm -f $(TESTDIR)/PrimitiveProjections.vo $(TESTDIR)/PrimitiveProjections.glob rm -f $(TESTDIR)/.*.vo.aux clean_config: rm -rf autom4te.cache rm -f configure config.log config.status rm -r Makefile clean : clean_coq clean_test rm -f $(GENERATED) rm -f $(CMOS_DPDUSAGE) $(CMOS_DPD2DOT) $(CMXS) $(ML_ALL:%.ml=%.o) *.cmi rm -f $(ML_ALL:%.ml=%.annot) rm -f $(DPD2DOT) $(DPDUSAGE) $(DPDPLUGIN) $(ECHO) "Use: make clean_config to remove configuration generated files" archi_clean: clean clean_config #------------------------------------------------------------------------------- coq-dpdgraph-1.0-8.19/README.md000066400000000000000000000221131457702451100156040ustar00rootroot00000000000000 # coq-dpdgraph [![Docker CI][docker-action-shield]][docker-action-link] [![Contributing][contributing-shield]][contributing-link] [![Code of Conduct][conduct-shield]][conduct-link] [![Zulip][zulip-shield]][zulip-link] [docker-action-shield]: https://github.com/coq-community/coq-dpdgraph/workflows/Docker%20CI/badge.svg?branch=coq-master [docker-action-link]: https://github.com/coq-community/coq-dpdgraph/actions?query=workflow:"Docker%20CI" [contributing-shield]: https://img.shields.io/badge/contributions-welcome-%23f7931e.svg [contributing-link]: https://github.com/coq-community/manifesto/blob/master/CONTRIBUTING.md [conduct-shield]: https://img.shields.io/badge/%E2%9D%A4-code%20of%20conduct-%23f15a24.svg [conduct-link]: https://github.com/coq-community/manifesto/blob/master/CODE_OF_CONDUCT.md [zulip-shield]: https://img.shields.io/badge/chat-on%20zulip-%23c1272d.svg [zulip-link]: https://coq.zulipchat.com/#narrow/stream/237663-coq-community-devs.20.26.20users Coq plugin that extracts the dependencies between Coq objects, and produces files with dependency information. Includes tools to visualize dependency graphs and find unused definitions. ## Meta - Author(s): - Anne Pacalet - Yves Bertot - Olivier Pons - Coq-community maintainer(s): - Anne Pacalet ([**@Karmaki**](https://github.com/Karmaki)) - Yves Bertot ([**@ybertot**](https://github.com/ybertot)) - License: [GNU Lesser General Public License v2.1](LICENSE) - Compatible Coq versions: master (use the corresponding branch or release for other Coq versions) - Compatible OCaml versions: 4.05.0 or later - Additional dependencies: - autoconf (except for releases) - [OCamlgraph](https://github.com/backtracking/ocamlgraph) - Coq namespace: `dpdgraph` - Related publication(s): none ## What's inside? First of all, it is a small tool (a Coq plugin) that extracts the dependencies between Coq objects, and produces a file (we suggest using the suffix .dpd) with this information. The idea is that other small tools can be then developed to process the .dpd files. At the moment, there is: - `dpd2dot` that reads these .dpd files and produces a graph file using .dot format (cf. http://www.graphviz.org/) that makes possible to view them; - `dpdusage`: to find unused definitions. Hope other tools later on to do more things. Feel free to contribute! ## How to get it You can: - either clone it from GitHub at: https://github.com/coq-community/coq-dpdgraph - or get the opam package named `coq-dpdgraph` from the opam-coq archive (repository "released") - or get the [latest distributed version](https://github.com/coq-community/coq-dpdgraph/releases) ### Compilation First download the archive and unpack it (or clone the repository), and change directory to the `coq-dpdgraph` directory. Depending on how you got hold of the directory, you may be in one of three situations: 1/ Makefile is present You should type the following command. $ make && make install 2/ configure is present, but no Makefile You should type the following command. $ ./configure && make && make install 3/ configure is not present, Makefile is not present You should type the following command. $ autoconf $ configure && make && make install By default, compilation will fail if there is any warning emitted by the ocaml compiler. This can be disabled by type make WARN_ERR= instead of `make` in all previous commands. ### Install using opam If you use opam, you can install `coq-dpdgraph` and `ocamlgraph` using $ opam repo add coq-released https://coq.inria.fr/opam/released $ opam install coq-dpdgraph ### Test If you install the archive by cloning the git repository, you have a sub-directory containing test files. These can be tested using the following command. $ make -s test to check if everything is ok. ## How to use it ### Requirements - to have compiled the tools (see above) - a compiled Coq file. You can for instance use `tests/Test.v` (a modified clone of Coq `List.v`) and compile it doing : ```shell $ coqc tests/Test.v ``` ### Generation of .dpd files The available commands are : - Generate dependencies between a list of objects: Print FileDependGraph . A module can be a file, or a sub-module in a file. Example : Print FileDependGraph M M2.A.B. Take all the objects of the specified modules and build the dependencies between them. - Generate the dependencies of one objects: Print DependGraph my_lemma. Analyse recursively the dependencies of ``my_lemma``. - Change the name of the generated file (default is ``graph.dpd``): Set DependGraph File "f.dpd". Useful when one needs to build several files in one session. **Advice:** you need to use ``Require`` to load the module that you want to explore, but don't use any ``Import``/``Export`` command because the tool is then unable to properly group the nodes by modules. **Example:** ``` $ ledit coqtop -R . dpdgraph -I tests/ Welcome to Coq 8.5 (April 2016) Coq < Require dpdgraph.dpdgraph. [Loading ML file dpdgraph.cmxs ... done] Coq < Require List. Coq < Print FileDependGraph List. Print FileDependGraph List. Fetching opaque proofs from disk for Coq.Lists.List Info: output dependencies in file graph.dpd Coq < Set DependGraph File "graph2.dpd". ^D ``` ### dpd2dot: from a .dpd file to a .dot file #### Graph generation ``` $ ./dpd2dot graph.dpd Info: read file graph.dpd Info: Graph output in graph.dot ``` There are some options : ``` $ ./dpd2dot -help Usage : ./dpd2dot [options] -o : name of output file (default: name of input file .dot) -with-defs : show everything (default) -without-defs : show only Prop objects -rm-trans : remove transitive dependencies (default) -keep-trans : keep transitive dependencies -debug : set debug mode -help Display this list of options --help Display this list of options ``` If the name of the output file finishes with ``.dot``, then the name before the ``.dot`` suffix is used as the graph name in the dot syntax. There are two exceptions: ``graph`` and ``digraph`` will be replaced with ``escaped_graph`` and ``escaped_digraph`` respectively. The only useful option at the moment is ``-without-defs`` that export only ``Prop`` objects to the graph (``Axiom``, ``Theorem``, ``Lemma``, etc). #### Graph visualisation You need : - [graphviz](http://www.graphviz.org/) (ie. dot tool) - a visualizer: we tested [zgrviewer](http://zvtm.sourceforge.net/zgrviewer.html), [xdot](https://pypi.python.org/pypi/xdot), [kgraphviewer](https://extragear.kde.org/apps/kgraphviewer/), but there are others. You can also convert .dot file to .svg file using : ``` $ dot -Tsvg file.dot > file.svg ``` You can then use ``firefox`` or ``inskape`` to view the ``.svg`` graph. The main advantage of using ``firefox`` is that the nodes are linked to the ``coqdoc`` pages if they have been generated in the same directory. But the navigation (zoom, moves) is very poor and slow. #### Graph interpretation The graph can be interpreted like this : - edge n1 --> n2 : n1 uses n2 - node : - green : proved lemma - orange : axiom/admitted lemma - dark pink : Definition, etc - light pink : Parameter, etc - violet : inductive, - blue : constructor, - multi-circled : not used (no predecessor in the graph) - yellow box : module - objects that are not in a yellow box are Coq objects. ### dpdusage: find unused definitions via .dpd file You can use ``dpdusage`` command to find unused definitions. Example: ``` $ ./dpdusage tests/graph2.dpd Info: read file tests/graph2.dpd Permutation_app_swap (0) ``` In the example above it reports that ``Permutation_app_swap`` was references 0 times. You can specify max number of references allowed (default 0) via ``-threshold`` command line option. ## Development information ### Generated ``.dpd`` format description ``` graph : obj_list obj : node | edge node : "N: " node_id node_name node_attributes ';' node_id : [0-9]+ node_name : '"' string '"' node_attributes : | empty | '[' node_attribute_list ']' node_attribute_list : | empty | node_attribute ',' node_attribute_list node_attribute : | kind=[cnst|inductive|construct] | prop=[yes|no] | path="m0.m1.m2" | body=[yes|no] edge : "E: " node_id node_id edge_attributes ';' edge_attributes : | empty | '[' edge_attribute_list ']' edge_attribute_list : | empty | edge_attribute ',' edge_attribute_list edge_attribute : | weight=NUM ``` The parser accept .dpd files as described above, but also any attribute for nodes and edges having the form : ``prop=val`` or ``prop="string..."`` or ``prop=NUM`` so that the generated ``.dpd`` can have new attributes without having to change the other tools. Each tool can then pick the attributes that it is able to handle; they are not supposed to raise an error whenever there is an unknown attribute. ## More information Also see: - [CHANGES](CHANGES.md) - [distributed versions](https://anne.pacalet.fr/dev/dpdgraph/) coq-dpdgraph-1.0-8.19/TODO000066400000000000000000000017661457702451100150300ustar00rootroot00000000000000TODO: transfer this to GitHub issues ! ---- Rebuild a demo ! -[2014-01-07] - utiliser ocamlgraph pour le calcul de le cloture transitive dans la fonction reduce_graph (cf. mail Julien Narboux) -[2013-09-12] - adaptation for OCaml 4.00.1 and Coq 8.4pl1 (April 2013) (.ml -> .ml4 + change in Declarations types) - tests are nor working as before : TODO #----------------- ~~ COQ part : - dependencies on [Parametric Morphism] are not detected... Well, this is not really true, but links seems to be in the wrong way (see tests/Morph.v) - add an option to limit the recursive search to a given level. - also use Section to organize the graph. ~~ translation to .dot ~~ other tools - try to export .dpd to sqlite database and use firefox extension ~~ visalisation - use ocamlgraph/viewgraph in order to be able to add actions on nodes - interactive visualisation ?... ~~ General : #----------------- ~~ Fixed : [07/08/2009] fixed bug : requests on internal COQ modules don't work... coq-dpdgraph-1.0-8.19/configure.ac000066400000000000000000000144621457702451100166230ustar00rootroot00000000000000#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # This file is part of the DpdGraph tools. # Copyright (C) 2009-2017 Anne Pacalet (Anne.Pacalet@free.fr) # and Yves Bertot (Yves.Bertot@inria.fr) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # This file is distributed under the terms of the # GNU Lesser General Public License Version 2.1 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # the script generated by autoconf from this input # will set several variables: (see AC_SUBST at the end of this file) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AC_INIT(coq-dpdgraph,1.0-8.19) AC_MSG_NOTICE(AC_PACKAGE_NAME version AC_PACKAGE_VERSION) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ new_section() { title="~~ $1 " banner=$(echo "$title" | sed -e 's/./~/g') AC_MSG_NOTICE($banner) AC_MSG_NOTICE($title) AC_MSG_NOTICE($banner) } #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ new_section "OCaml compilers" AC_CHECK_PROG(OCAMLC,ocamlc,ocamlc,no) if test "$OCAMLC" = no ; then AC_MSG_ERROR(Cannot find ocamlc.) fi AC_MSG_CHECKING(ocamlc version) OCAMLVERSION=$($OCAMLC -version) AC_MSG_RESULT($OCAMLVERSION) case $OCAMLVERSION in 0.*|1.*|2.*|3.*) AC_MSG_ERROR(AC_PACKAGE_NAME needs ocaml version 4.00.0 or higher) ;; esac AC_MSG_CHECKING(ocamlc -safe-string option) case $OCAMLVERSION in 4.00.*|4.01.*) AC_MSG_RESULT(no) ;; *) OCAML_EXTRA_OPTS="-safe-string"; AC_MSG_RESULT(yes) ;; esac AC_MSG_CHECKING(ocaml library path) OCAMLLIB=$($OCAMLC -where | tr -d '\r') AC_MSG_RESULT($OCAMLLIB) # then we look for ocamlopt; if not present, we issue a warning # if the version is not the same, we also discard it # we set OCAMLBEST to "opt" or "byte", whether ocamlopt is available or not AC_CHECK_PROG(OCAMLOPT,ocamlopt,ocamlopt,no) OCAMLBEST=byte if test "$OCAMLOPT" = no ; then AC_MSG_WARN(cannot find ocamlopt; bytecode compilation only.) else AC_MSG_CHECKING(ocamlopt version) TMPVERSION=$($OCAMLOPT -version) if test "$TMPVERSION" != "$OCAMLVERSION" ; then AC_MSG_RESULT($TMPVERSION) AC_MSG_WARN(version differs from ocamlc; ocamlopt discarded.) OCAMLOPT=no else AC_MSG_RESULT(ok) OCAMLBEST=opt fi fi AC_CHECK_PROG(OCAMLCDOTOPT,ocamlc.opt,ocamlc.opt,no) if test "$OCAMLCDOTOPT" != no ; then AC_MSG_CHECKING(ocamlc.opt version) TMPVERSION=$($OCAMLCDOTOPT -version) if test "$TMPVERSION" != "$OCAMLVERSION" ; then AC_MSG_RESULT($TMPVERSION) AC_MSG_WARN(version differs from ocamlc; ocamlc.opt discarded.) else AC_MSG_RESULT(ok) OCAMLC=$OCAMLCDOTOPT fi fi AC_CHECK_PROG(OCAMLOPTDOTOPT,ocamlopt.opt,ocamlopt.opt,no) if test "$OCAMLOPTDOTOPT" != no ; then AC_MSG_CHECKING(ocamlc.opt version) TMPVERSION=$($OCAMLOPTDOTOPT -version) if test "$TMPVERSION" != "$OCAMLVERSION" ; then AC_MSG_RESULT($TMPVERSION) AC_MSG_WARN(version differs from ocamlc; ocamlopt.opt discarded.) else AC_MSG_RESULT(ok) OCAMLOPT=$OCAMLOPTDOTOPT fi fi # ocamldep, ocamllex and ocamlyacc should also be present in the path AC_CHECK_PROG(OCAMLDEP,ocamldep,ocamldep,no) if test "$OCAMLDEP" = no ; then AC_MSG_ERROR(Cannot find ocamldep.) fi AC_CHECK_PROG(OCAMLLEX,ocamllex,ocamllex,no) if test "$OCAMLLEX" = no ; then AC_MSG_ERROR(Cannot find ocamllex.) else AC_CHECK_PROG(OCAMLLEXDOTOPT,ocamllex.opt,ocamllex.opt,no) if test "$OCAMLLEXDOTOPT" != no ; then OCAMLLEX=$OCAMLLEXDOTOPT fi fi AC_CHECK_PROG(OCAMLYACC,ocamlyacc,ocamlyacc,no) if test "$OCAMLYACC" = no ; then AC_MSG_ERROR(Cannot find ocamlyacc.) fi AC_CHECK_PROG(OCAMLDOC,ocamldoc,ocamldoc,true) if test "$OCAMLDOC" = true ; then AC_MSG_WARN(Cannot find ocamldoc) else AC_CHECK_PROG(OCAMLDOCOPT,ocamldoc.opt,ocamldoc.opt,no) if test "$OCAMLDOCOPT" != no ; then OCAMLDOC=$OCAMLDOCOPT fi fi #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ new_section "ocamlgraph" AC_CHECK_PROG(OCAMLFIND,ocamlfind,ocamlfind,no) if test "$OCAMLFIND" = "no" ; then AC_MSG_WARN(No ocamlfind detected) else AC_MSG_CHECKING(ocamlfind compatibility) OCAMLLIB_BY_FINDLIB=$(ocamlfind printconf stdlib | tr -d '\r') if test "$OCAMLLIB_BY_FINDLIB" = "$OCAMLLIB" ; then AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) AC_MSG_WARN(ocamlfind detected but disabled. Standard libraries differ:) echo " ocamlc: '$OCAMLLIB'" echo " ocamlfind: '$OCAMLLIB_BY_FINDLIB'" OCAMLFIND="no" fi fi AC_MSG_CHECKING(ocamlgraph package) if test "$OCAMLFIND" = "no"; then if test -f "$OCAMLLIB/ocamlgraph/graph.cmxa" ; then OCAMLGRAPH=yes else OCAMLGRAPH=no fi OCAMLGRAPH_PATH=+ocamlgraph else OCAMLGRAPH_PATH=$(ocamlfind query ocamlgraph | tr -d '\r') if test "$OCAMLGRAPH_PATH" = "" ;then OCAMLGRAPH=no fi fi if test "$OCAMLGRAPH" = no ; then AC_MSG_RESULT(no) AC_MSG_ERROR(ocamlgraph is not found.) else AC_MSG_RESULT($OCAMLGRAPH_PATH) fi #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ new_section "Coq" AC_CHECK_PROG(COQC,coqc,coqc,no) if test "$COQC" = no ; then AC_MSG_ERROR(Cannot find coqc.) fi AC_MSG_CHECKING(coq version) COQVERSION=$($COQC -v | sed -n -e 's|.*version *\(.*\)$|\1|p' ) AC_MSG_RESULT($COQVERSION) case $COQVERSION in 8.[[0-9]][[^0-9]]*|8.10*) AC_MSG_ERROR(AC_PACKAGE_NAME needs Coq version 8.11 or higher) ;; esac AC_CHECK_PROG(COQ_MAKEFILE,coq_makefile,coq_makefile,no) if test "$COQ_MAKEFILE" = no ; then AC_MSG_ERROR(cannot find coq_makefile.) fi BINDIR_PRE=$(which coqc) BINDIR=$(dirname $BINDIR_PRE) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ new_section "creating Makefile" # substitutions to perform AC_SUBST(PACKAGE_NAME) AC_SUBST(PACKAGE_VERSION) AC_SUBST(OCAMLC) AC_SUBST(OCAMLOPT) AC_SUBST(OCAMLDEP) AC_SUBST(OCAMLLEX) AC_SUBST(OCAMLYACC) # AC_SUBST(OCAMLDOC) TODO: use it in Makefile # AC_SUBST(OCAMLBEST) TODO: use it in Makefile # AC_SUBST(OCAMLVERSION) # AC_SUBST(OCAMLLIB) AC_SUBST(OCAML_EXTRA_OPTS) AC_SUBST(COQC) AC_SUBST(COQ_MAKEFILE) AC_SUBST(BINDIR) AC_SUBST(OCAMLGRAPH_PATH) # Finally create the Makefile from Makefile.in AC_OUTPUT(Makefile) chmod a-w Makefile #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ coq-dpdgraph-1.0-8.19/coq-dpdgraph.opam000066400000000000000000000020301457702451100175500ustar00rootroot00000000000000opam-version: "2.0" maintainer: "palmskog@gmail.com" version: "dev" homepage: "https://github.com/coq-community/coq-dpdgraph" dev-repo: "git+https://github.com/coq-community/coq-dpdgraph.git" bug-reports: "https://github.com/coq-community/coq-dpdgraph/issues" license: "LGPL-2.1-only" synopsis: "Compute dependencies between Coq objects (definitions, theorems) and produce graphs" description: """ Coq plugin that extracts the dependencies between Coq objects, and produces files with dependency information. Includes tools to visualize dependency graphs and find unused definitions.""" build: [ ["autoconf"] {dev} ["./configure"] [make "-j%{jobs}%" "WARN_ERR="] ] run-test: [make "test-suite"] install: [make "install" "BINDIR=%{bin}%"] depends: [ "ocaml" {>= "4.05.0"} "coq" {= "dev"} "conf-autoconf" {build & dev} "ocamlgraph" ] tags: [ "category:Miscellaneous/Coq Extensions" "keyword:dependency graph" "keyword:dependency analysis" "logpath:dpdgraph" ] authors: [ "Anne Pacalet" "Yves Bertot" "Olivier Pons" ] coq-dpdgraph-1.0-8.19/coqdoc.css000077500000000000000000000041221457702451100163120ustar00rootroot00000000000000body { padding: 0px 0px; margin: 0px 0px; background-color: white } #page { display: block; padding: 0px; margin: 0px; padding-bottom: 10px; } #header { display: block; position: relative; padding: 0; margin: 0; vertical-align: middle; border-bottom-style: solid; border-width: thin } #header h1 { padding: 0; margin: 0;} /* Contenu */ #main{ display: block; padding: 10px; overflow: hidden; font-size: 100%; line-height: 100% } #main a.idref:visited {color : #416DFF; text-decoration : none; } #main a.idref:link {color : #416DFF; text-decoration : none; } #main a.idref:hover {text-decoration : none; } #main a.idref:active {text-decoration : none; } #main a.modref:visited {color : #416DFF; text-decoration : none; } #main a.modref:link {color : #416DFF; text-decoration : none; } #main a.modref:hover {text-decoration : none; } #main a.modref:active {text-decoration : none; } #main .keyword { color : #cf1d1d } #main { color: black } #main .section { background-color:#90bdff; font-size : 175% } #main .doc { margin: 0px; padding: 10px; font-family: sans-serif; font-size: 100%; line-height: 100%; font-weight:bold; color: black; background-color: #90bdff; border-style: plain} .inlinecode { display: inline; font-family: monospace } .code { display: block; font-family: monospace } /* Pied de page */ #footer { font-size: 65%; font-family: sans-serif; } #footer a:visited { color: blue; } #footer a:link { text-decoration: none; color: #888888; } .id { display: inline; } .id[type="constructor"] { color: rgb(60%,0%,0%); } .id[type="var"] { color: rgb(40%,0%,40%); } .id[type="definition"] { color: rgb(0%,40%,0%); } .id[type="lemma"] { color: rgb(0%,40%,0%); } .id[type="inductive"] { color: rgb(0%,0%,80%); } .id[type="keyword"] { color : #cf1d1d; /* color: black; */ } coq-dpdgraph-1.0-8.19/dpd2dot.ml000066400000000000000000000053211457702451100162210ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) let version_option = ref false let out_file = ref None let set_out_file file = out_file := Some file let graphname = ref None let set_graphname name = graphname := Some name let spec_args = [ ("-o", Arg.String set_out_file, ": name of output file (default: name of input file .dot)"); ("-with-defs", Arg.Set Dpd_compute.with_defs, ": show everything (default)"); ("-without-defs", Arg.Clear Dpd_compute.with_defs, ": show only Prop objects"); ("-rm-trans", Arg.Set Dpd_compute.reduce_trans, ": remove transitive dependencies (default)"); ("-keep-trans", Arg.Clear Dpd_compute.reduce_trans, ": keep transitive dependencies"); ("-graphname", Arg.String set_graphname, ": name of graph (default: name of input file)"); ("-debug", Arg.Set Dpd_compute.debug_flag, ": set debug mode"); ("-v", Arg.Set version_option, ": print version and exit"); ] let do_file n f = try Dpd_compute.feedback "read file %s@." f; let g = Dpd_lex.read f in let g = Dpd_compute.build_graph g in Dpd_compute.simplify_graph g; let dotfile = match !out_file with | None -> (Filename.chop_extension f)^".dot" | Some f -> if n = 0 then f else (Filename.chop_extension f)^"."^(string_of_int n)^".dot" in let graph_name = match !graphname with | None -> (Filename.chop_extension f) | Some name -> name in Dpd_dot.graph_file graph_name dotfile g with Dpd_compute.Error err -> Dpd_compute.pp_error err let main () = let usage_msg = "Usage : "^(Sys.argv.(0))^" [options]" in let args = ref [] in let memo_arg arg = args := arg :: !args in Arg.parse spec_args memo_arg usage_msg; if !version_option then Format.printf "This is '%s' (part of DpdGraph tools - version %s)@." (Filename.basename Sys.argv.(0)) Version.version else match !args with | [] -> Dpd_compute.error "no source file to process ?@."; Arg.usage spec_args usage_msg | f::[] -> do_file 0 f | l -> ignore (List.fold_left (fun n f -> do_file n f; n+1) 1 l) let () = main () coq-dpdgraph-1.0-8.19/dpd2dot.mli000066400000000000000000000004241457702451100163710ustar00rootroot00000000000000val version_option : bool ref val out_file : string option ref val set_out_file : string -> unit val graphname : string option ref val set_graphname : string -> unit val spec_args : (string * Arg.spec * string) list val do_file : int -> string -> unit val main : unit -> unit coq-dpdgraph-1.0-8.19/dpd_compute.ml000066400000000000000000000135371457702451100171740ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) let debug_flag = ref false let with_defs = ref true let reduce_trans = ref true let pp intro format = Format.printf "%s" intro ; Format.printf format let debug format = if !debug_flag then pp "(debug): " format else Format.ifprintf Format.std_formatter format let error format = pp "Error: " format let warning format = pp "Warning: " format let feedback format = pp "Info: " format type error = | OpenFileError of string | LexicalError of Lexing.position * string | UnterminatedComment of Lexing.position option | ParsingError of Lexing.position * Lexing.position | EdgeWithoutNode of int | NodeWithSameId of int * string * string exception Error of error let pp_lex_pos fmt p = Format.fprintf fmt "(line:%d, character:%d)" p.Lexing.pos_lnum (p.Lexing.pos_cnum - p.Lexing.pos_bol) let pp_lex_inter fmt (p1, p2) = let l1 = p1.Lexing.pos_lnum in let c1 = p1.Lexing.pos_cnum - p1.Lexing.pos_bol in let l2 = p2.Lexing.pos_lnum in let c2 = p2.Lexing.pos_cnum - p2.Lexing.pos_bol in if l1 = l2 then if c1 = c2 then pp_lex_pos fmt p1 else Format.fprintf fmt "(line:%d, character:%d-%d)" l1 c1 c2 else Format.fprintf fmt "between %a and %a" pp_lex_pos p1 pp_lex_pos p2 let pp_error = function | OpenFileError msg -> error "%s.@." msg | LexicalError (pos, str) -> error "%a: illegal character '%s'.@." pp_lex_pos pos str | UnterminatedComment (Some pos) -> error "unterminated comment (started near %a).@." pp_lex_pos pos | UnterminatedComment None -> error "unterminated comment.@." | ParsingError (p1, p2) -> error "parsing error %a.@." pp_lex_inter (p1, p2) | EdgeWithoutNode node_id -> error "no node with number %d: cannot build edge.@." node_id | NodeWithSameId (node_id, old_name, name) -> error "a node named '%s' already has the number %d. \ Cannot create new node named '%s' with the same number.@." old_name node_id name let get_attrib a attribs = try Some (List.assoc a attribs) with Not_found -> None let bool_attrib a attribs = match get_attrib a attribs with | Some "yes" -> Some true | Some "no" -> Some false | Some _ (* TODO : warning ? *) | None -> None module Node = struct type t = int * string * (string * string) list let id (id, _, _) = id let name (_, name, _) = name let attribs (_, _, attribs) = attribs let get_attrib a n = get_attrib a (attribs n) let bool_attrib a n = bool_attrib a (attribs n) let hash n = id n let equal n1 n2 = id n1 = id n2 let compare n1 n2 = compare (id n1) (id n2) end module Edge = struct type t = (string * string) list let get_attrib a e = get_attrib a e let bool_attrib a e = bool_attrib a e let compare e1 e2 = compare e1 e2 let default = [] end module G = Graph.Imperative.Digraph.ConcreteLabeled(Node)(Edge) type t_obj = N of Node.t | E of (int * int * (string * string) list) let build_graph lobj = let g = G.create () in let node_tbl = Hashtbl.create 10 in let get_node id = try Hashtbl.find node_tbl id with Not_found -> raise (Error (EdgeWithoutNode id)) in let add_obj o = match o with | N ((id, _, _) as n) -> begin try let old_n = Hashtbl.find node_tbl id in raise (Error (NodeWithSameId (id, Node.name old_n, Node.name n))) with Not_found -> Hashtbl.add node_tbl id n; let n = G.V.create n in G.add_vertex g n end | E (id1, id2, attribs) -> let e = G.E.create (get_node id1) attribs (get_node id2) in G.add_edge_e g e in List.iter add_obj lobj; g (** remove edge (n1 -> n2) iff n2 is indirectly reachable by n1, * or if n1 and n2 are the same *) let reduce_graph g = (* a table in which each node is mapped to the set of indirected accessible * nodes *) let module Vset = Set.Make (G.V) in let reach_tbl = Hashtbl.create (G.nb_vertex g) in let rec reachable v = try Hashtbl.find reach_tbl v (* already done *) with Not_found -> let nb_succ_before = List.length (G.succ g v) in let add_succ_reachable acc s = let acc = (* add [s] successors *) List.fold_left (fun set x -> Vset.add x set) acc (G.succ g s) in (Vset.union acc (if Node.equal v s then Vset.empty else reachable s)) in let acc = List.fold_left add_succ_reachable Vset.empty (G.succ g v) in (* try to remove edges *) let rm_edge sv = if Vset.mem sv acc then G.remove_edge g v sv in List.iter rm_edge (G.succ g v); let nb_succ_after = List.length (G.succ g v) in debug "Reduce for %s : %d -> %d@." (Node.name v) nb_succ_before nb_succ_after; Hashtbl.add reach_tbl v acc; acc in G.iter_vertex (fun v -> ignore (reachable v)) g let remove_node g n = let transfer_edges p = G.remove_edge g p n; List.iter (fun s -> G.add_edge g p s) (G.succ g n) in List.iter transfer_edges (G.pred g n); G.remove_vertex g n (* also remove edges n -> s *) let remove_some_nodes g = let do_v v = match Node.bool_attrib "prop" v with | None | Some false -> remove_node g v | Some true -> () in G.iter_vertex do_v g let simplify_graph g = if not !with_defs then remove_some_nodes g; if !reduce_trans then reduce_graph g; coq-dpdgraph-1.0-8.19/dpd_compute.mli000066400000000000000000000105211457702451100173330ustar00rootroot00000000000000val debug_flag : bool ref val with_defs : bool ref val reduce_trans : bool ref val pp : string -> ('a, Format.formatter, unit) format -> 'a val debug : ('a, Format.formatter, unit) format -> 'a val error : ('a, Format.formatter, unit) format -> 'a val warning : ('a, Format.formatter, unit) format -> 'a val feedback : ('a, Format.formatter, unit) format -> 'a type error = OpenFileError of string | LexicalError of Lexing.position * string | UnterminatedComment of Lexing.position option | ParsingError of Lexing.position * Lexing.position | EdgeWithoutNode of int | NodeWithSameId of int * string * string exception Error of error val pp_lex_pos : Format.formatter -> Lexing.position -> unit val pp_lex_inter : Format.formatter -> Lexing.position * Lexing.position -> unit val pp_error : error -> unit val get_attrib : 'a -> ('a * 'b) list -> 'b option val bool_attrib : 'a -> ('a * string) list -> bool option module Node : sig type t = int * string * (string * string) list val id : 'a * 'b * 'c -> 'a val name : 'a * 'b * 'c -> 'b val attribs : 'a * 'b * 'c -> 'c val get_attrib : 'a -> 'b * 'c * ('a * 'd) list -> 'd option val bool_attrib : 'a -> 'b * 'c * ('a * string) list -> bool option val hash : 'a * 'b * 'c -> 'a val equal : 'a * 'b * 'c -> 'a * 'd * 'e -> bool val compare : 'a * 'b * 'c -> 'a * 'd * 'e -> int end module Edge : sig type t = (string * string) list val get_attrib : 'a -> ('a * 'b) list -> 'b option val bool_attrib : 'a -> ('a * string) list -> bool option val compare : 'a -> 'a -> int val default : 'a list end module G : sig type t = Graph.Imperative.Digraph.ConcreteLabeled(Node)(Edge).t module V : sig type t = Node.t val compare : t -> t -> int val hash : t -> int val equal : t -> t -> bool type label = Node.t val create : label -> t val label : t -> label end type vertex = V.t module E : sig type t = Node.t * Edge.t * Node.t val compare : t -> t -> int type vertex = V.t val src : t -> vertex val dst : t -> vertex type label = Edge.t val create : vertex -> label -> vertex -> t val label : t -> label end type edge = E.t val is_directed : bool val is_empty : t -> bool val nb_vertex : t -> int val nb_edges : t -> int val out_degree : t -> vertex -> int val in_degree : t -> vertex -> int val mem_vertex : t -> vertex -> bool val mem_edge : t -> vertex -> vertex -> bool val mem_edge_e : t -> edge -> bool val find_edge : t -> vertex -> vertex -> edge val find_all_edges : t -> vertex -> vertex -> edge list val succ : t -> vertex -> vertex list val pred : t -> vertex -> vertex list val succ_e : t -> vertex -> edge list val pred_e : t -> vertex -> edge list val iter_vertex : (vertex -> unit) -> t -> unit val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a val iter_edges : (vertex -> vertex -> unit) -> t -> unit val fold_edges : (vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a val iter_edges_e : (edge -> unit) -> t -> unit val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a val map_vertex : (vertex -> vertex) -> t -> t val iter_succ : (vertex -> unit) -> t -> vertex -> unit val iter_pred : (vertex -> unit) -> t -> vertex -> unit val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val iter_succ_e : (edge -> unit) -> t -> vertex -> unit val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val iter_pred_e : (edge -> unit) -> t -> vertex -> unit val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val create : ?size:int -> unit -> t val clear : t -> unit val copy : t -> t val add_vertex : t -> vertex -> unit val remove_vertex : t -> vertex -> unit val add_edge : t -> vertex -> vertex -> unit val add_edge_e : t -> edge -> unit val remove_edge : t -> vertex -> vertex -> unit val remove_edge_e : t -> edge -> unit end type t_obj = N of Node.t | E of (int * int * (string * string) list) val build_graph : t_obj list -> G.t val reduce_graph : G.t -> unit val remove_node : G.t -> G.vertex -> unit val remove_some_nodes : G.t -> unit val simplify_graph : G.t -> unit coq-dpdgraph-1.0-8.19/dpd_dot.ml000066400000000000000000000151421457702451100163000ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) module C = Dpd_compute module G = Dpd_compute.G module Node = Dpd_compute.Node let color_soft_yellow = (0xFFFFC3) let color_pale_orange = (0xFFE1C3) let color_medium_orange = (0xFFB57F) let color_soft_green = (0x7FFFD4) let color_medium_green = (0x00E598) let color_soft_pink = (0xFACDEF) let color_medium_pink = (0xF070D1) let color_soft_purple = (0xE2CDFA) let color_soft_blue = (0x7FAAFF) type attr_kind = | Aid of string | Astr of string | Acolor of int | Aint of int | Aurl of string let split_string s i = let s1 = String.sub s 0 i in let s2 = String.sub s (i+1) ((String.length s) - (i+1)) in s1, s2 let mk_url n = let df, dm = match Node.get_attrib "path" n with | None -> "", "" | Some d -> try let i = String.index d '.' in let df, dm = split_string d i in df, dm^"." with Not_found -> d, "" in df^".html"^"#"^dm^(Node.name n) let node_attribs g n = let attr = [] in let color = match Node.get_attrib "kind" n with | Some s when s = "cnst" -> begin let is_prop = match Node.bool_attrib "prop" n with | Some b -> b | None -> false in match Node.bool_attrib "body" n with | Some true -> (if is_prop then color_soft_green else color_medium_pink) | _ -> (if is_prop then color_medium_orange else color_soft_pink) end | Some s when s = "inductive"-> color_soft_purple | Some s when s = "construct" -> color_soft_blue | _ -> (0x000000) (* TODO warning *) in let attr = (Aid "fillcolor", Acolor color) :: attr in let used = List.length (G.pred g n) > 0 in let attr = if used then attr else (Aid "peripheries", Aint 3) :: attr in let label = String.escaped (Node.name n) in let url = mk_url n in let attr = (Aid "URL", Aurl url)::attr in let attr = (Aid "label", Astr label)::attr in attr let add_node_in_subgraph sg_tbl n sg = let rec get_subgraph sg = try Hashtbl.find sg_tbl sg with Not_found -> (* new subgraph *) C.debug "New subgraph : %s@." sg; try let i = String.rindex sg '.' in let d, n = split_string sg i in let (level, ssg, nodes) = get_subgraph d in C.debug "add subgraph %s in %s@." n d; Hashtbl.replace sg_tbl d (level, (sg,n)::ssg, nodes); (level+1, [], []) with Not_found -> (* simple subgraph *) 0, [], [] in let (l, ssg, nodes) = get_subgraph sg in Hashtbl.replace sg_tbl sg (l, ssg, n::nodes) let str2id s = String.map (function '.' | '\'' -> '_' | c -> c) s let rec print_attribs sep fmt attribs = let print_a fmt a = match a with | Aid s -> Format.fprintf fmt "%s" s | Astr s -> Format.fprintf fmt "\"%s\"" s | Aurl s -> Format.fprintf fmt "<%s>" s | Acolor color -> Format.fprintf fmt "\"#%06X\"" color | Aint i -> Format.fprintf fmt "%d" i in let print_attrib fmt (a, b) = Format.fprintf fmt "%a=%a" print_a a print_a b in match attribs with [] -> () | a::[] -> Format.fprintf fmt "%a" print_attrib a | a::tl -> Format.fprintf fmt "%a%s%a" print_attrib a sep (print_attribs sep) tl let node_dot_id n = (* was Node.id n *) let dirname = match Node.get_attrib "path" n with | None -> "" | Some d -> d in str2id (dirname^"_"^(Node.name n)) (* the subgraph table map sg full name to (sglevel, sg_subgraphs, sg_nodes) * The level is 0 for toplevel subgraphs. * sg_subgraphs is a list of (sg_full_name, sg_short_name). * sg_nodes is the list of nodes in the subgraph. * *) let print_subgraphs fmt sg_tbl = let rec print_subgraph sg_path sg_name (sglev, ssg, nodes) = let sg_id = "cluster_"^(str2id sg_path) in let sg_attribs = (Aid "label", Astr sg_name):: (Aid "fillcolor", Acolor (color_soft_yellow - 32*sglev)):: (Aid "labeljust", Aid "l"):: (Aid "style", Aid "filled"):: [] in Format.fprintf fmt "subgraph %s { %a @." sg_id (print_attribs "; ") sg_attribs; List.iter print_sub_subgraph ssg; List.iter (fun n -> Format.fprintf fmt "%s; " (node_dot_id n)) nodes; Format.fprintf fmt "};@." and print_sub_subgraph (sg_id, sg_name) = try let ssg = Hashtbl.find sg_tbl sg_id in print_subgraph sg_id sg_name ssg with Not_found -> assert false in let print_top_subgraph sg ((l,_,_) as info) = if l = 0 then print_subgraph sg sg info in Hashtbl.iter print_top_subgraph sg_tbl (** don't use Graph.Graphviz because of attribute limitations (URL, subgraph, * ...) *) let print_graph name fmt graph = let subgraphs = Hashtbl.create 7 in let print_node n = let attribs = node_attribs graph n in Format.fprintf fmt "%s [%a] ;@." (node_dot_id n) (print_attribs ", ") attribs; let _ = match Node.get_attrib "path" n with None | Some "" -> () | Some d -> add_node_in_subgraph subgraphs n d in () in let print_edge e = let edge_attribs = [] in (* let edge_attribs = (Aid "style", Aid "bold")::edge_attribs in *) Format.fprintf fmt " %s -> %s [%a] ;@." (node_dot_id (G.E.src e)) (node_dot_id (G.E.dst e)) (print_attribs ", ") edge_attribs in let escaped_name = if (String.compare name "graph" = 0) || (String.compare name "digraph" = 0) then String.concat "" ["escaped_"; name] else name in Format.fprintf fmt "digraph %s {@." escaped_name; Format.fprintf fmt " graph [ratio=0.5]@."; Format.fprintf fmt " node [style=filled]@."; G.iter_vertex print_node graph; G.iter_edges_e print_edge graph; print_subgraphs fmt subgraphs; Format.fprintf fmt "} /* END */@." let graph_file graphname filename g = let file, oc = try filename, open_out filename with Sys_error msg -> C.warning "cannot open file: %s@." msg; let file = Filename.temp_file "coqdpd" ".dpd" in file, open_out file in C.feedback "Graph output in %s@." file; let fmt = Format.formatter_of_out_channel oc in print_graph graphname fmt g; close_out oc coq-dpdgraph-1.0-8.19/dpd_dot.mli000066400000000000000000000022341457702451100164470ustar00rootroot00000000000000module C = Dpd_compute module G = Dpd_compute.G module Node = Dpd_compute.Node val color_soft_yellow : int val color_pale_orange : int val color_medium_orange : int val color_soft_green : int val color_medium_green : int val color_soft_pink : int val color_medium_pink : int val color_soft_purple : int val color_soft_blue : int type attr_kind = Aid of string | Astr of string | Acolor of int | Aint of int | Aurl of string val split_string : string -> int -> string * string val mk_url : 'a * string * (string * string) list -> string val node_attribs : G.t -> G.vertex -> (attr_kind * attr_kind) list val add_node_in_subgraph : (string, int * (string * string) list * 'a list) Hashtbl.t -> 'a -> string -> unit val str2id : string -> string val print_attribs : string -> Format.formatter -> (attr_kind * attr_kind) list -> unit val node_dot_id : 'a * string * (string * string) list -> string val print_subgraphs : Format.formatter -> (string, int * (string * string) list * ('a * string * (string * string) list) list) Hashtbl.t -> unit val print_graph : String.t -> Format.formatter -> G.t -> unit val graph_file : String.t -> string -> G.t -> unit coq-dpdgraph-1.0-8.19/dpd_lex.mli000066400000000000000000000006051457702451100164510ustar00rootroot00000000000000module P = Dpd_parse val comment_pos : Lexing.position option ref val start_comment : Lexing.position -> unit val __ocaml_lex_tables : Lexing.lex_tables val token : Lexing.lexbuf -> P.token val __ocaml_lex_token_rec : Lexing.lexbuf -> int -> P.token val comment : Lexing.lexbuf -> unit val __ocaml_lex_comment_rec : Lexing.lexbuf -> int -> unit val read : string -> Dpd_compute.t_obj list coq-dpdgraph-1.0-8.19/dpd_lex.mll000066400000000000000000000055471457702451100164660ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2017 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) { module P = Dpd_parse (* tokens *) let comment_pos = ref None let start_comment pos = comment_pos := Some pos } let blank = [' ' '\t' ] let newline = ['\n'] let letter = ['a'-'z']|['A'-'Z'] let digit = ['0'-'9'] let number = ['0'-'9']+ let first_letter = letter | '_' let other_letter = first_letter | digit let ident = first_letter other_letter* rule token = parse | blank+ { token lexbuf } (* skip blanks *) | newline { Lexing.new_line lexbuf; token lexbuf } | "/*" { start_comment (Lexing.lexeme_start_p lexbuf); let _ = comment lexbuf in token lexbuf } | "//" [^'\n']* newline { token lexbuf } | "N:" { P.NODE } | "E:" { P.EDGE } | '[' { P.LBRACKET } | ']' { P.RBRACKET } | "," { P.COMMA } | ";" { P.SEMICOL } | "=" { P.EQUAL } | ident as s { P.IDENT s } | number as s { P.NUM (int_of_string s) } | '"' ([^'"']+ as str) '"' { P.STRING (str)} | eof { P.EOF } | _ { let str = String.escaped (Lexing.lexeme lexbuf) in let pos = Lexing.lexeme_start_p lexbuf in let err = Dpd_compute.LexicalError (pos, str) in raise (Dpd_compute.Error err) } and comment = parse "*/" { () } | newline { Lexing.new_line lexbuf; comment lexbuf } | _ { comment lexbuf } | eof { let err = Dpd_compute.UnterminatedComment (!comment_pos) in raise (Dpd_compute.Error err) } { (* @raise Dpd_compute.Error e *) let read filename = let buf_in = try open_in filename with Sys_error msg -> let err = Dpd_compute.OpenFileError msg in raise (Dpd_compute.Error err) in let lexbuf = Lexing.from_channel buf_in in let init_pos = lexbuf.Lexing.lex_curr_p in lexbuf.Lexing.lex_curr_p <- { init_pos with Lexing.pos_fname = filename }; let info = P.graph token lexbuf in close_in buf_in; info } coq-dpdgraph-1.0-8.19/dpd_parse.mly000066400000000000000000000032061457702451100170130ustar00rootroot00000000000000%{ (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) %} %token IDENT %token STRING %token NUM %token LBRACKET RBRACKET %token NODE EDGE EQUAL COMMA SEMICOL EOF %left LBRACKET %nonassoc IDENT %type graph %start graph %% graph : obj_list EOF { $1 } obj_list : | obj { [$1] } | obj obj_list { $1::$2 } obj : | node SEMICOL { $1 } | edge SEMICOL { $1 } | error { let p_start = symbol_start_pos () in let p_end = symbol_end_pos () in let err = Dpd_compute.ParsingError (p_start, p_end) in raise (Dpd_compute.Error err) } node : NODE NUM STRING opt_attribs { Dpd_compute.N ($2, $3, $4) } edge : EDGE NUM NUM opt_attribs { Dpd_compute.E ($2, $3, $4) } opt_attribs : | /* empty */ { [] } | LBRACKET attribs RBRACKET { $2 } attribs : | /* empty */ { [] } | attrib COMMA attribs { $1::$3 } attrib : | IDENT EQUAL attrib_value { ($1, $3) } attrib_value: | IDENT { $1 } | STRING { $1 } | NUM { string_of_int $1 } %% coq-dpdgraph-1.0-8.19/dpdgraph.mllib000066400000000000000000000000311457702451100171320ustar00rootroot00000000000000Searchdepend Graphdepend coq-dpdgraph-1.0-8.19/dpdgraph.v000066400000000000000000000000511457702451100163020ustar00rootroot00000000000000Declare ML Module "coq-dpdgraph.plugin". coq-dpdgraph-1.0-8.19/dpdusage.ml000066400000000000000000000055061457702451100164620ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) module G = Dpd_compute.G module Node = Dpd_compute.Node let version_option = ref false let print_path_option = ref true let threshold_option = ref 0 let spec_args = [ ("-with-defs", Arg.Set Dpd_compute.with_defs, ": show everything (default)"); ("-without-defs", Arg.Clear Dpd_compute.with_defs, ": show only Prop objects"); ("-rm-trans", Arg.Set Dpd_compute.reduce_trans, ": remove transitive dependencies (default)"); ("-keep-trans", Arg.Clear Dpd_compute.reduce_trans, ": keep transitive dependencies"); ("-debug", Arg.Set Dpd_compute.debug_flag, ": set debug mode"); ("-threshold", Arg.Set_int threshold_option, ": Max number of references allowed (default 0)"); ("-with-path", Arg.Set print_path_option, ": print path (default)"); ("-without-path", Arg.Clear print_path_option, ": do not print path"); ("-v", Arg.Set version_option, ": print version and exit"); ] let print_usage g t = let print_node n = let d = (G.in_degree g n) in if d <= t then if !print_path_option then let prefix = match Node.get_attrib "path" n with | None -> "" | Some d -> d^":" in Format.printf "%s%s\t(%d)\n" prefix (Node.name n) d else Format.printf "%s\t(%d)\n" (Node.name n) d in G.iter_vertex print_node g let do_file _ f = try Dpd_compute.feedback "read file %s@." f; let g = Dpd_lex.read f in let g = Dpd_compute.build_graph g in Dpd_compute.simplify_graph g; print_usage g !threshold_option with Dpd_compute.Error err -> Dpd_compute.pp_error err let main () = let usage_msg = "Usage : "^(Sys.argv.(0))^" [options] " in let args = ref [] in let memo_arg arg = args := arg :: !args in Arg.parse spec_args memo_arg usage_msg; if !version_option then Format.printf "This is '%s' (part of DpdGraph tools - version %s)@." (Filename.basename Sys.argv.(0)) Version.version else match !args with | [] -> Dpd_compute.error "no source file to process ?@."; Arg.usage spec_args usage_msg | f::[] -> do_file 0 f | l -> ignore (List.fold_left (fun n f -> do_file n f; n+1) 1 l) let () = main () coq-dpdgraph-1.0-8.19/dpdusage.mli000066400000000000000000000004501457702451100166240ustar00rootroot00000000000000module G = Dpd_compute.G module Node = Dpd_compute.Node val version_option : bool ref val print_path_option : bool ref val threshold_option : int ref val spec_args : (string * Arg.spec * string) list val print_usage : G.t -> int -> unit val do_file : 'a -> string -> unit val main : unit -> unit coq-dpdgraph-1.0-8.19/graphdepend.mlg000066400000000000000000000221431457702451100173120ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) DECLARE PLUGIN "coq-dpdgraph.plugin" { open Pp open Stdarg let debug msg = if false then Feedback.msg_debug msg let feedback msg = Feedback.msg_notice (str "Info: " ++ msg) let warning msg = Feedback.msg_warning (str "Warning: " ++ msg) let error msg = CErrors.user_err msg let filename = ref "graph.dpd" let get_dirlist_grefs dirlist = let selected_gref = ref [] in let select gref kind env sigma constr = if Search.module_filter (SearchInside dirlist) gref kind env sigma constr then (debug (str "Select " ++ Printer.pr_global gref); selected_gref := gref::!selected_gref) in Search.generic_search (Global.env()) (Evd.from_env (Global.env())) select; !selected_gref let is_prop gref id = try let t, ctx = Typeops.type_of_global_in_context (Global.env()) gref in (* Beware of this code, not considered entirely correct, but I don't know how to fix it. *) let env = Environ.push_context ~strict:false (UVars.AbstractContext.repr ctx) (Global.env ()) in let s = (Typeops.infer_type env t).Environ.utj_type in Sorts.is_prop s with _ -> begin warning (str "unable to determine the type of the type for " ++ str id); false end;; module G = struct module Node = struct type t = int * Names.GlobRef.t let id n = fst n let gref n = snd n let compare n1 n2 = compare (id n1) (id n2) let equal n1 n2 = 0 = compare n1 n2 let full_name n = let qualid = Nametab.shortest_qualid_of_global Names.Id.Set.empty (gref n) in Libnames.string_of_qualid qualid let split_name n = let qualid = Nametab.shortest_qualid_of_global Names.Id.Set.empty (gref n) in let dirpath, ident = Libnames.repr_qualid qualid in let dirpath = Names.DirPath.to_string dirpath in let dirpath = if dirpath = "<>" then "" else dirpath in let name = Names.Id.to_string ident in (dirpath, name) (* let mod_list = Names.repr_dirpath dir_path in let rec dirname l = match l with [] -> "" | m::[] -> Names.string_of_id m | d::tl -> (dirname tl)^"."^(Names.string_of_id d) in (dirname mod_list, name) *) end module Edge = struct type t = Node.t * Node.t * int let src (n1, _n2, _nb) = n1 let dst (_n1, n2, _nb) = n2 let nb_use (_n1, _n2, nb) = nb let compare e1 e2 = let cmp_src = Node.compare (src e1) (src e2) in if cmp_src = 0 then Node.compare (dst e1) (dst e2) else cmp_src end module Edges = Set.Make (Edge) module GMap = Map.Make (Names.GlobRef.UserOrd) type t = int GMap.t * Edges.t let empty = GMap.empty, Edges.empty (** new numbers to store global references in nodes *) let gref_cpt = ref 0 let nb_vertex (nds, _eds) = Hashtbl.length nds let get_node (nds, eds) gref = try Some (GMap.find gref nds, gref) with Not_found -> None (** *) let add_node ((nds, eds) as g) gref = match get_node g gref with | Some n -> g, n | None -> gref_cpt := !gref_cpt + 1; let nds = GMap.add gref !gref_cpt nds in let n = (!gref_cpt, gref) in (nds, eds), n let add_edge (nds, eds) n1 n2 nb = nds, Edges.add (n1, n2, nb) eds (* let succ (_nds, eds) n = let do_e e acc = if Node.equal n (Edge.src e) then (Edge.dst e)::acc else acc in Edges.fold do_e eds [] let pred (_nds, eds) n = let do_e e acc = if Node.equal n (Edge.dst e) then (Edge.src e)::acc else acc in Edges.fold do_e eds [] *) let iter_vertex fv (nds, _eds) = GMap.iter (fun gref id -> fv (id, gref)) nds let iter_edges_e fe (_nds, eds) = Edges.iter fe eds end (** add the dependencies of gref in the graph (gref is already in). * If [all], add also the nodes of the dependancies that are not in, * and return the list of the new nodes, * If not all, don't add nodes, and return an empty list. *) let add_gref_dpds graph ~all n_gref todo = let gref = G.Node.gref n_gref in debug (str "Add dpds " ++ Printer.pr_global gref); let add_dpd dpd nb_use (g, td) = match G.get_node g dpd with | Some n -> let g = G.add_edge g n_gref n nb_use in g, td | None -> if all then let g, n = G.add_node g dpd in let g = G.add_edge g n_gref n nb_use in g, n::td else g, td in try let data = Searchdepend.collect_dependance gref in let graph, todo = Searchdepend.Data.fold add_dpd data (graph, todo) in graph, todo with Searchdepend.NoDef gref -> (* nothing to do *) graph, todo (** add gref node and add it to the todo list * to process its dependencies later. *) let add_gref_only (graph, todo) gref = debug (str "Add " ++ Printer.pr_global gref); let graph, n = G.add_node graph gref in let todo = n::todo in graph, todo (** add the gref in [l] and build the dependencies according to [all] *) let add_gref_list_and_dpds graph ~all l = let graph, todo = List.fold_left add_gref_only (graph, []) l in let rec add_gref_dpds_rec graph todo = match todo with | [] -> graph | n::todo -> let graph, todo = add_gref_dpds graph ~all n todo in add_gref_dpds_rec graph todo in let graph = add_gref_dpds_rec graph todo in graph (** Don't forget to update the README file if something is changed here *) module Out : sig val file : G.t -> unit end = struct let add_cnst_attrib acc cnst = let env = Global.env() in let cb = Environ.lookup_constant cnst env in let acc = match cb.Declarations.const_body with | Declarations.OpaqueDef _ | Declarations.Def _ -> ("body", "yes")::acc | Declarations.Undef _ -> ("body", "no")::acc | Declarations.Primitive _ -> ("body", "no")::acc in acc let add_gref_attrib acc gref id = let is_prop = is_prop gref id in let acc = ("prop", if is_prop then "yes" else "no")::acc in let acc = match gref with | Names.GlobRef.ConstRef cnst -> let acc = ("kind", "cnst")::acc in add_cnst_attrib acc cnst | Names.GlobRef.IndRef _ -> let acc = ("kind", "inductive")::acc in acc | Names.GlobRef.ConstructRef _ -> let acc = ("kind", "construct")::acc in acc | Names.GlobRef.VarRef _ -> assert false in acc let pp_attribs fmt attribs = List.iter (fun (a,b) -> Format.fprintf fmt "%s=%s, " a b) attribs let out_node fmt g n = let id = G.Node.id n in let gref = G.Node.gref n in let dirname, name = G.Node.split_name n in let acc = if dirname = "" then [] else [("path", "\""^dirname^"\"")] in let acc = add_gref_attrib acc gref name in Format.fprintf fmt "N: %d \"%s\" [%a];@." id name pp_attribs acc let out_edge fmt _g e = let edge_attribs = ("weight", string_of_int (G.Edge.nb_use e))::[] in Format.fprintf fmt "E: %d %d [%a];@." (G.Node.id (G.Edge.src e)) (G.Node.id (G.Edge.dst e)) pp_attribs edge_attribs let out_graph fmt g = G.iter_vertex (out_node fmt g) g; G.iter_edges_e (out_edge fmt g) g let file graph = try let oc = open_out !filename in feedback (str "output dependencies in file " ++ (str !filename)); out_graph (Format.formatter_of_out_channel oc) graph; close_out oc with Sys_error msg -> error (str "cannot open file: " ++ (str msg)); end let mk_dpds_graph gref = let graph = G.empty in let all = true in (* get all the dependencies recursively *) let graph = add_gref_list_and_dpds graph ~all [gref] in Out.file graph let file_graph_depend dirlist = let graph = G.empty in let grefs = get_dirlist_grefs dirlist in let all = false in (* then add the dependencies only to existing nodes *) let graph = add_gref_list_and_dpds graph ~all grefs in Out.file graph let locate_mp_dirpath qid = try Nametab.dirpath_of_module (Nametab.locate_module qid) with Not_found -> let msg = str "Unknown module" ++ spc() ++ Libnames.pr_qualid qid in CErrors.user_err ?loc:qid.CAst.loc msg } VERNAC COMMAND EXTEND DependGraphSetFile CLASSIFIED AS QUERY | ["Set" "DependGraph" "File" string(str)] -> { filename := str } END (* VERNAC ARGUMENT EXTEND dirpath | [ string(str) ] -> { Globnames.dirpath_of_string str } END VERNAC ARGUMENT EXTEND dirlist | [ dirpath(d) dirlist(l)] -> { d::l } | [ dirpath(d) ] -> { [d] } END *) VERNAC COMMAND EXTEND DependGraph CLASSIFIED AS QUERY | ["Print" "DependGraph" reference(ref) ] -> { mk_dpds_graph (Nametab.global ref) } | ["Print" "FileDependGraph" reference_list(dl) ] -> { file_graph_depend (List.map locate_mp_dirpath dl) } END coq-dpdgraph-1.0-8.19/meta.yml000066400000000000000000000221251457702451100160010ustar00rootroot00000000000000--- fullname: coq-dpdgraph shortname: coq-dpdgraph opam_name: coq-dpdgraph organization: coq-community community: true action: true plugin: true branch: 'coq-v8.19' synopsis: >- Compute dependencies between Coq objects (definitions, theorems) and produce graphs description: |- Coq plugin that extracts the dependencies between Coq objects, and produces files with dependency information. Includes tools to visualize dependency graphs and find unused definitions. authors: - name: Anne Pacalet - name: Yves Bertot - name: Olivier Pons maintainers: - name: Anne Pacalet nickname: Karmaki - name: Yves Bertot nickname: ybertot opam-file-maintainer: palmskog@gmail.com opam-file-version: 8.19.dev license: fullname: GNU Lesser General Public License v2.1 identifier: LGPL-2.1-only supported_coq_versions: text: 8.19 (use the corresponding branch or release for other Coq versions) opam: '{>= "8.19" & < "8.20~"}' supported_ocaml_versions: text: 4.05.0 or later opam: '{>= "4.05.0"}' dependencies: - opam: name: conf-autoconf version: '{build & dev}' description: |- autoconf (except for releases) - opam: name: ocamlgraph description: |- [OCamlgraph](https://github.com/backtracking/ocamlgraph) tested_coq_opam_versions: - version: 8.19 namespace: dpdgraph keywords: - name: dependency graph - name: dependency analysis categories: - name: Miscellaneous/Coq Extensions build: |- ## What's inside? First of all, it is a small tool (a Coq plugin) that extracts the dependencies between Coq objects, and produces a file (we suggest using the suffix .dpd) with this information. The idea is that other small tools can be then developed to process the .dpd files. At the moment, there is: - `dpd2dot` that reads these .dpd files and produces a graph file using .dot format (cf. http://www.graphviz.org/) that makes possible to view them; - `dpdusage`: to find unused definitions. Hope other tools later on to do more things. Feel free to contribute! ## How to get it You can: - either clone it from GitHub at: https://github.com/coq-community/coq-dpdgraph - or get the opam package named `coq-dpdgraph` from the opam-coq archive (repository "released") - or get the [latest distributed version](https://github.com/coq-community/coq-dpdgraph/releases) ### Compilation First download the archive and unpack it (or clone the repository), and change directory to the `coq-dpdgraph` directory. Depending on how you got hold of the directory, you may be in one of three situations: 1/ Makefile is present You should type the following command. $ make && make install 2/ configure is present, but no Makefile You should type the following command. $ ./configure && make && make install 3/ configure is not present, Makefile is not present You should type the following command. $ autoconf $ configure && make && make install By default, compilation will fail if there is any warning emitted by the ocaml compiler. This can be disabled by type make WARN_ERR= instead of `make` in all previous commands. ### Install using opam If you use opam, you can install `coq-dpdgraph` and `ocamlgraph` using $ opam repo add coq-released https://coq.inria.fr/opam/released $ opam install coq-dpdgraph ### Test If you install the archive by cloning the git repository, you have a sub-directory containing test files. These can be tested using the following command. $ make -s test to check if everything is ok. documentation: | ## How to use it ### Requirements - to have compiled the tools (see above) - a compiled Coq file. You can for instance use `tests/Test.v` (a modified clone of Coq `List.v`) and compile it doing : ```shell $ coqc tests/Test.v ``` ### Generation of .dpd files The available commands are : - Generate dependencies between a list of objects: Print FileDependGraph . A module can be a file, or a sub-module in a file. Example : Print FileDependGraph M M2.A.B. Take all the objects of the specified modules and build the dependencies between them. - Generate the dependencies of one objects: Print DependGraph my_lemma. Analyse recursively the dependencies of ``my_lemma``. - Change the name of the generated file (default is ``graph.dpd``): Set DependGraph File "f.dpd". Useful when one needs to build several files in one session. **Advice:** you need to use ``Require`` to load the module that you want to explore, but don't use any ``Import``/``Export`` command because the tool is then unable to properly group the nodes by modules. **Example:** ``` $ ledit coqtop -R . dpdgraph -I tests/ Welcome to Coq 8.5 (April 2016) Coq < Require dpdgraph.dpdgraph. [Loading ML file dpdgraph.cmxs ... done] Coq < Require List. Coq < Print FileDependGraph List. Print FileDependGraph List. Fetching opaque proofs from disk for Coq.Lists.List Info: output dependencies in file graph.dpd Coq < Set DependGraph File "graph2.dpd". ^D ``` ### dpd2dot: from a .dpd file to a .dot file #### Graph generation ``` $ ./dpd2dot graph.dpd Info: read file graph.dpd Info: Graph output in graph.dot ``` There are some options : ``` $ ./dpd2dot -help Usage : ./dpd2dot [options] -o : name of output file (default: name of input file .dot) -with-defs : show everything (default) -without-defs : show only Prop objects -rm-trans : remove transitive dependencies (default) -keep-trans : keep transitive dependencies -debug : set debug mode -help Display this list of options --help Display this list of options ``` If the name of the output file finishes with ``.dot``, then the name before the ``.dot`` suffix is used as the graph name in the dot syntax. There are two exceptions: ``graph`` and ``digraph`` will be replaced with ``escaped_graph`` and ``escaped_digraph`` respectively. The only useful option at the moment is ``-without-defs`` that export only ``Prop`` objects to the graph (``Axiom``, ``Theorem``, ``Lemma``, etc). #### Graph visualisation You need : - [graphviz](http://www.graphviz.org/) (ie. dot tool) - a visualizer: we tested [zgrviewer](http://zvtm.sourceforge.net/zgrviewer.html), [xdot](https://pypi.python.org/pypi/xdot), [kgraphviewer](https://extragear.kde.org/apps/kgraphviewer/), but there are others. You can also convert .dot file to .svg file using : ``` $ dot -Tsvg file.dot > file.svg ``` You can then use ``firefox`` or ``inskape`` to view the ``.svg`` graph. The main advantage of using ``firefox`` is that the nodes are linked to the ``coqdoc`` pages if they have been generated in the same directory. But the navigation (zoom, moves) is very poor and slow. #### Graph interpretation The graph can be interpreted like this : - edge n1 --> n2 : n1 uses n2 - node : - green : proved lemma - orange : axiom/admitted lemma - dark pink : Definition, etc - light pink : Parameter, etc - violet : inductive, - blue : constructor, - multi-circled : not used (no predecessor in the graph) - yellow box : module - objects that are not in a yellow box are Coq objects. ### dpdusage: find unused definitions via .dpd file You can use ``dpdusage`` command to find unused definitions. Example: ``` $ ./dpdusage tests/graph2.dpd Info: read file tests/graph2.dpd Permutation_app_swap (0) ``` In the example above it reports that ``Permutation_app_swap`` was references 0 times. You can specify max number of references allowed (default 0) via ``-threshold`` command line option. ## Development information ### Generated ``.dpd`` format description ``` graph : obj_list obj : node | edge node : "N: " node_id node_name node_attributes ';' node_id : [0-9]+ node_name : '"' string '"' node_attributes : | empty | '[' node_attribute_list ']' node_attribute_list : | empty | node_attribute ',' node_attribute_list node_attribute : | kind=[cnst|inductive|construct] | prop=[yes|no] | path="m0.m1.m2" | body=[yes|no] edge : "E: " node_id node_id edge_attributes ';' edge_attributes : | empty | '[' edge_attribute_list ']' edge_attribute_list : | empty | edge_attribute ',' edge_attribute_list edge_attribute : | weight=NUM ``` The parser accept .dpd files as described above, but also any attribute for nodes and edges having the form : ``prop=val`` or ``prop="string..."`` or ``prop=NUM`` so that the generated ``.dpd`` can have new attributes without having to change the other tools. Each tool can then pick the attributes that it is able to handle; they are not supposed to raise an error whenever there is an unknown attribute. ## More information Also see: - [CHANGES](CHANGES.md) - [distributed versions](https://anne.pacalet.fr/dev/dpdgraph/) --- coq-dpdgraph-1.0-8.19/searchdepend.mlg000066400000000000000000000066161457702451100174650ustar00rootroot00000000000000(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) (* This file is part of the DpdGraph tools. *) (* Copyright (C) 2009-2015 Anne Pacalet (Anne.Pacalet@free.fr) *) (* and Yves Bertot (Yves.Bertot@inria.fr) *) (* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *) (* This file is distributed under the terms of the *) (* GNU Lesser General Public License Version 2.1 *) (* (see the enclosed LICENSE file for mode details) *) (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*) DECLARE PLUGIN "coq-dpdgraph.plugin" { open Pp open Stdarg module Data = struct type t = int Names.GlobRef.Map.t let empty = Names.GlobRef.Map.empty let add gref d = let n = try Names.GlobRef.Map.find gref d with Not_found -> 0 in Names.GlobRef.Map.add gref (n+1) d (* [f gref n acc] *) let fold f d acc = Names.GlobRef.Map.fold f d acc end let add_identifier (x:Names.Id.t)(d:Data.t) = failwith ("SearchDep does not expect to find plain identifiers :" ^ Names.Id.to_string x) let add_sort (s:Sorts.t)(d:Data.t) = d let add_constant (cst:Names.Constant.t)(d:Data.t) = Data.add (Names.GlobRef.ConstRef cst) d let add_inductive ((k,i):Names.inductive)(d:Data.t) = Data.add (Names.GlobRef.IndRef (k, i)) d let add_constructor(((k,i),j):Names.constructor)(d:Data.t) = Data.add (Names.GlobRef.ConstructRef ((k,i),j)) d let collect_long_names avoid (c:Constr.t) (acc:Data.t) = let rec add acc c = let open Constr in match kind c with | Var x -> add_identifier x acc | Sort s -> add_sort s acc | Const cst -> add_constant (UVars.out_punivs cst) acc | Ind (i,_) when not (List.exists (Names.MutInd.CanOrd.equal (fst i)) avoid) -> add_inductive i acc | Construct (cnst,_) when not (List.exists (Names.MutInd.CanOrd.equal (fst (fst cnst))) avoid) -> add_constructor cnst acc | Case({ci_ind=i},_,_,_,_,_,_) -> add_inductive i (Constr.fold add acc c) | _ -> Constr.fold add acc c in add acc c exception NoDef of Names.GlobRef.t let collect_dependance gref = (* This will change to Names.GlobRef in 8.10 *) let open Names in let open GlobRef in match gref with | VarRef _ -> assert false | ConstRef cst -> let cb = Environ.lookup_constant cst (Global.env()) in let cl = match Global.body_of_constant_body Library.indirect_accessor cb with Some (e,_,_) -> [e] | None -> [] in let cl = cb.Declarations.const_type :: cl in List.fold_right (collect_long_names []) cl Data.empty | IndRef i | ConstructRef (i,_) -> let _, indbody = Global.lookup_inductive i in let ca = indbody.Declarations.mind_user_lc in Array.fold_right (collect_long_names [fst i]) ca Data.empty let display_dependance gref = let display d = let pp gr n s = Printer.pr_global gr ++ str "(" ++ int n ++ str ")" ++ spc() ++s in Feedback.msg_notice (str"[" ++ ((Data.fold pp) d (str "]"))) in try let data = collect_dependance gref in display data with NoDef gref -> CErrors.user_err (Printer.pr_global gref ++ str " has no value") } VERNAC COMMAND EXTEND Searchdepend CLASSIFIED AS QUERY | ["SearchDepend" global(ref) ] -> { display_dependance (Nametab.global ref) } END coq-dpdgraph-1.0-8.19/style.css000077500000000000000000000000421457702451100161770ustar00rootroot00000000000000.coq { background: lightblue; } coq-dpdgraph-1.0-8.19/tests/000077500000000000000000000000001457702451100154705ustar00rootroot00000000000000coq-dpdgraph-1.0-8.19/tests/Morph.cmd000066400000000000000000000002641457702451100172440ustar00rootroot00000000000000Require Import dpdgraph.dpdgraph. Require Morph. Set DependGraph File "Morph.dpd". Print FileDependGraph Morph. Set DependGraph File "Morph_rw.dpd". Print DependGraph Morph.rw. coq-dpdgraph-1.0-8.19/tests/Morph.dot.oracle000066400000000000000000000046431457702451100205400ustar00rootroot00000000000000digraph tests/Morph { graph [ratio=0.5] node [style=filled] Morph_rw [label="rw", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_FsmpM [label="FsmpM", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_FsmpM_Proper [label="FsmpM_Proper", URL=, fillcolor="#FFB57F"] ; Morph_Fsmp [label="Fsmp", URL=, fillcolor="#FACDEF"] ; Morph_FequivR [label="FequivR", URL=, fillcolor="#7FFFD4"] ; Morph_FequivR_Transitive [label="FequivR_Transitive", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_FequivR_Symmetric [label="FequivR_Symmetric", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_FequivR_Reflexive [label="FequivR_Reflexive", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_FequivR_relation [label="FequivR_relation", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morph_Fequiv_trans [label="Fequiv_trans", URL=, fillcolor="#FFB57F"] ; Morph_Fequiv_sym [label="Fequiv_sym", URL=, fillcolor="#FFB57F"] ; Morph_Fequiv_refl [label="Fequiv_refl", URL=, fillcolor="#FFB57F"] ; Morph_Fequiv [label="Fequiv", URL=, fillcolor="#FACDEF"] ; Morph_F [label="F", URL=, fillcolor="#FACDEF"] ; Morph_rw -> Morph_FsmpM_Proper [] ; Morph_rw -> Morph_FequivR [] ; Morph_FsmpM -> Morph_FsmpM_Proper [] ; Morph_FsmpM_Proper -> Morph_Fsmp [] ; Morph_FsmpM_Proper -> Morph_Fequiv [] ; Morph_Fsmp -> Morph_F [] ; Morph_FequivR -> Morph_Fequiv_trans [] ; Morph_FequivR -> Morph_Fequiv_sym [] ; Morph_FequivR -> Morph_Fequiv_refl [] ; Morph_FequivR_Transitive -> Morph_Fequiv_trans [] ; Morph_FequivR_Symmetric -> Morph_Fequiv_sym [] ; Morph_FequivR_Reflexive -> Morph_Fequiv_refl [] ; Morph_FequivR_relation -> Morph_Fequiv [] ; Morph_Fequiv_trans -> Morph_Fequiv [] ; Morph_Fequiv_sym -> Morph_Fequiv [] ; Morph_Fequiv_refl -> Morph_Fequiv [] ; Morph_Fequiv -> Morph_F [] ; subgraph cluster_Morph { label="Morph"; fillcolor="#FFFFC3"; labeljust=l; style=filled Morph_F; Morph_Fequiv; Morph_Fequiv_refl; Morph_Fequiv_sym; Morph_Fequiv_trans; Morph_FequivR_relation; Morph_FequivR_Reflexive; Morph_FequivR_Symmetric; Morph_FequivR_Transitive; Morph_FequivR; Morph_Fsmp; Morph_FsmpM_Proper; Morph_FsmpM; Morph_rw; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/Morph.dpd.oracle000066400000000000000000000032741457702451100205200ustar00rootroot00000000000000N: 14 "F" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 13 "Fequiv" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 5 "FequivR" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 8 "FequivR_Reflexive" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 7 "FequivR_Symmetric" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 6 "FequivR_Transitive" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 9 "FequivR_relation" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 12 "Fequiv_refl" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 11 "Fequiv_sym" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 10 "Fequiv_trans" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 4 "Fsmp" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 2 "FsmpM" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 3 "FsmpM_Proper" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 1 "rw" [body=yes, kind=cnst, prop=yes, path="Morph", ]; E: 1 3 [weight=1, ]; E: 1 4 [weight=5, ]; E: 1 5 [weight=1, ]; E: 1 13 [weight=8, ]; E: 1 14 [weight=6, ]; E: 2 3 [weight=1, ]; E: 2 4 [weight=3, ]; E: 2 13 [weight=4, ]; E: 2 14 [weight=6, ]; E: 3 4 [weight=1, ]; E: 3 13 [weight=2, ]; E: 3 14 [weight=4, ]; E: 4 14 [weight=2, ]; E: 5 10 [weight=1, ]; E: 5 11 [weight=1, ]; E: 5 12 [weight=1, ]; E: 5 13 [weight=2, ]; E: 5 14 [weight=2, ]; E: 6 10 [weight=1, ]; E: 6 13 [weight=1, ]; E: 6 14 [weight=1, ]; E: 7 11 [weight=1, ]; E: 7 13 [weight=1, ]; E: 7 14 [weight=1, ]; E: 8 12 [weight=1, ]; E: 8 13 [weight=1, ]; E: 8 14 [weight=1, ]; E: 9 13 [weight=2, ]; E: 9 14 [weight=2, ]; E: 10 13 [weight=3, ]; E: 10 14 [weight=3, ]; E: 11 13 [weight=2, ]; E: 11 14 [weight=2, ]; E: 12 13 [weight=1, ]; E: 12 14 [weight=1, ]; E: 13 14 [weight=2, ]; coq-dpdgraph-1.0-8.19/tests/Morph.v000066400000000000000000000013011457702451100167370ustar00rootroot00000000000000Require Import Setoid. Parameter F : Type. Parameter Fequiv : F -> F -> Prop. Axiom Fequiv_refl : forall f, Fequiv f f. Axiom Fequiv_sym : forall f1 f2, Fequiv f1 f2 -> Fequiv f2 f1. Axiom Fequiv_trans : forall f1 f2 f3, Fequiv f1 f2 -> Fequiv f2 f3 -> Fequiv f1 f3. Add Parametric Relation : F Fequiv reflexivity proved by Fequiv_refl symmetry proved by Fequiv_sym transitivity proved by Fequiv_trans as FequivR. Parameter Fsmp : F -> F. Add Parametric Morphism : Fsmp with signature Fequiv ==> Fequiv as FsmpM. Proof. Admitted. Theorem rw : forall f1 f2, Fequiv f2 f1 -> Fequiv f1 (Fsmp f1) -> Fequiv f1 (Fsmp f2). Proof. intros f1 f2 He H1. rewrite He. trivial. Qed. (* Print rw. *) coq-dpdgraph-1.0-8.19/tests/Morph_rw.dot.oracle000066400000000000000000000171071457702451100212470ustar00rootroot00000000000000digraph tests/Morph_rw { graph [ratio=0.5] node [style=filled] Morph_rw [label="rw", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Morphisms_trans_sym_co_inv_impl_morphism [label="trans_sym_co_inv_impl_morphism", URL=, fillcolor="#7FFFD4"] ; Morph_FsmpM_Proper [label="FsmpM_Proper", URL=, fillcolor="#FFB57F"] ; Morph_F [label="F", URL=, fillcolor="#FACDEF"] ; Morph_Fsmp [label="Fsmp", URL=, fillcolor="#FACDEF"] ; RelationClasses_Equivalence_PER [label="Equivalence_PER", URL=, fillcolor="#7FFFD4"] ; Morph_Fequiv [label="Fequiv", URL=, fillcolor="#FACDEF"] ; Morph_FequivR [label="FequivR", URL=, fillcolor="#7FFFD4"] ; Morph_Fequiv_trans [label="Fequiv_trans", URL=, fillcolor="#FFB57F"] ; Morph_Fequiv_refl [label="Fequiv_refl", URL=, fillcolor="#FFB57F"] ; Morph_Fequiv_sym [label="Fequiv_sym", URL=, fillcolor="#FFB57F"] ; RelationClasses_Equivalence [label="Equivalence", URL=, fillcolor="#E2CDFA"] ; RelationClasses_Build_Equivalence [label="Build_Equivalence", URL=, fillcolor="#7FAAFF"] ; RelationClasses_Symmetric [label="Symmetric", URL=, fillcolor="#F070D1"] ; RelationClasses_Reflexive [label="Reflexive", URL=, fillcolor="#F070D1"] ; Relation_Definitions_relation [label="relation", URL=, fillcolor="#F070D1"] ; RelationClasses_Transitive [label="Transitive", URL=, fillcolor="#F070D1"] ; RelationClasses_Equivalence_Transitive [label="Equivalence_Transitive", URL=, fillcolor="#7FFFD4"] ; RelationClasses_Equivalence_Symmetric [label="Equivalence_Symmetric", URL=, fillcolor="#7FFFD4"] ; RelationClasses_PER [label="PER", URL=, fillcolor="#E2CDFA"] ; RelationClasses_Build_PER [label="Build_PER", URL=, fillcolor="#7FAAFF"] ; Morphisms_Proper [label="Proper", URL=, fillcolor="#F070D1"] ; Morphisms_respectful [label="respectful", URL=, fillcolor="#F070D1"] ; Basics_flip [label="flip", URL=, fillcolor="#F070D1"] ; Basics_impl [label="impl", URL=, fillcolor="#F070D1"] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 [label="trans_sym_co_inv_impl_morphism_obligation_1", URL=, fillcolor="#7FFFD4"] ; RelationClasses_PER_Symmetric [label="PER_Symmetric", URL=, fillcolor="#7FFFD4"] ; RelationClasses_symmetry [label="symmetry", URL=, fillcolor="#7FFFD4"] ; RelationClasses_PER_Transitive [label="PER_Transitive", URL=, fillcolor="#7FFFD4"] ; RelationClasses_transitivity [label="transitivity", URL=, fillcolor="#7FFFD4"] ; Morph_rw -> Morphisms_trans_sym_co_inv_impl_morphism [] ; Morph_rw -> Morph_FsmpM_Proper [] ; Morph_rw -> RelationClasses_Equivalence_PER [] ; Morph_rw -> Morph_FequivR [] ; Morphisms_trans_sym_co_inv_impl_morphism -> Morphisms_Proper [] ; Morphisms_trans_sym_co_inv_impl_morphism -> Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 [] ; Morph_FsmpM_Proper -> Morph_Fsmp [] ; Morph_FsmpM_Proper -> Morph_Fequiv [] ; Morph_FsmpM_Proper -> Morphisms_Proper [] ; Morph_FsmpM_Proper -> Morphisms_respectful [] ; Morph_Fsmp -> Morph_F [] ; RelationClasses_Equivalence_PER -> RelationClasses_Equivalence_Transitive [] ; RelationClasses_Equivalence_PER -> RelationClasses_Equivalence_Symmetric [] ; RelationClasses_Equivalence_PER -> RelationClasses_PER [] ; RelationClasses_Equivalence_PER -> RelationClasses_Build_PER [] ; Morph_Fequiv -> Morph_F [] ; Morph_FequivR -> Morph_Fequiv_trans [] ; Morph_FequivR -> Morph_Fequiv_refl [] ; Morph_FequivR -> Morph_Fequiv_sym [] ; Morph_FequivR -> RelationClasses_Equivalence [] ; Morph_FequivR -> RelationClasses_Build_Equivalence [] ; Morph_Fequiv_trans -> Morph_Fequiv [] ; Morph_Fequiv_refl -> Morph_Fequiv [] ; Morph_Fequiv_sym -> Morph_Fequiv [] ; RelationClasses_Equivalence -> RelationClasses_Symmetric [] ; RelationClasses_Equivalence -> RelationClasses_Reflexive [] ; RelationClasses_Equivalence -> RelationClasses_Transitive [] ; RelationClasses_Build_Equivalence -> RelationClasses_Symmetric [] ; RelationClasses_Build_Equivalence -> RelationClasses_Reflexive [] ; RelationClasses_Build_Equivalence -> RelationClasses_Transitive [] ; RelationClasses_Symmetric -> Relation_Definitions_relation [] ; RelationClasses_Reflexive -> Relation_Definitions_relation [] ; RelationClasses_Transitive -> Relation_Definitions_relation [] ; RelationClasses_Equivalence_Transitive -> RelationClasses_Equivalence [] ; RelationClasses_Equivalence_Symmetric -> RelationClasses_Equivalence [] ; RelationClasses_PER -> RelationClasses_Symmetric [] ; RelationClasses_PER -> RelationClasses_Transitive [] ; RelationClasses_Build_PER -> RelationClasses_Symmetric [] ; RelationClasses_Build_PER -> RelationClasses_Transitive [] ; Morphisms_Proper -> Relation_Definitions_relation [] ; Morphisms_respectful -> Relation_Definitions_relation [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> Morphisms_respectful [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> Basics_flip [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> Basics_impl [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> RelationClasses_PER_Symmetric [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> RelationClasses_symmetry [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> RelationClasses_PER_Transitive [] ; Morphisms_trans_sym_co_inv_impl_morphism_obligation_1 -> RelationClasses_transitivity [] ; RelationClasses_PER_Symmetric -> RelationClasses_PER [] ; RelationClasses_symmetry -> RelationClasses_Symmetric [] ; RelationClasses_PER_Transitive -> RelationClasses_PER [] ; RelationClasses_transitivity -> RelationClasses_Transitive [] ; subgraph cluster_Basics { label="Basics"; fillcolor="#FFFFC3"; labeljust=l; style=filled Basics_impl; Basics_flip; }; subgraph cluster_RelationClasses { label="RelationClasses"; fillcolor="#FFFFC3"; labeljust=l; style=filled RelationClasses_transitivity; RelationClasses_PER_Transitive; RelationClasses_symmetry; RelationClasses_PER_Symmetric; RelationClasses_Build_PER; RelationClasses_PER; RelationClasses_Equivalence_Symmetric; RelationClasses_Equivalence_Transitive; RelationClasses_Transitive; RelationClasses_Reflexive; RelationClasses_Symmetric; RelationClasses_Build_Equivalence; RelationClasses_Equivalence; RelationClasses_Equivalence_PER; }; subgraph cluster_Morphisms { label="Morphisms"; fillcolor="#FFFFC3"; labeljust=l; style=filled Morphisms_trans_sym_co_inv_impl_morphism_obligation_1; Morphisms_respectful; Morphisms_Proper; Morphisms_trans_sym_co_inv_impl_morphism; }; subgraph cluster_Relation_Definitions { label="Relation_Definitions"; fillcolor="#FFFFC3"; labeljust=l; style=filled Relation_Definitions_relation; }; subgraph cluster_Morph { label="Morph"; fillcolor="#FFFFC3"; labeljust=l; style=filled Morph_Fequiv_sym; Morph_Fequiv_refl; Morph_Fequiv_trans; Morph_FequivR; Morph_Fequiv; Morph_Fsmp; Morph_F; Morph_FsmpM_Proper; Morph_rw; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/Morph_rw.dpd.oracle000066400000000000000000000100641457702451100212230ustar00rootroot00000000000000N: 20 "Equivalence_PER" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 33 "Equivalence_Symmetric" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 32 "Equivalence_Transitive" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 18 "F" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 21 "Fequiv" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 22 "FequivR" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 24 "Fequiv_refl" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 25 "Fequiv_sym" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 23 "Fequiv_trans" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 19 "Fsmp" [body=no, kind=cnst, prop=no, path="Morph", ]; N: 17 "FsmpM_Proper" [body=no, kind=cnst, prop=yes, path="Morph", ]; N: 41 "PER_Symmetric" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 43 "PER_Transitive" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 36 "Proper" [body=yes, kind=cnst, prop=no, path="Morphisms", ]; N: 29 "Reflexive" [body=yes, kind=cnst, prop=no, path="RelationClasses", ]; N: 28 "Symmetric" [body=yes, kind=cnst, prop=no, path="RelationClasses", ]; N: 31 "Transitive" [body=yes, kind=cnst, prop=no, path="RelationClasses", ]; N: 38 "flip" [body=yes, kind=cnst, prop=no, path="Basics", ]; N: 39 "impl" [body=yes, kind=cnst, prop=no, path="Basics", ]; N: 30 "relation" [body=yes, kind=cnst, prop=no, path="Relation_Definitions", ]; N: 37 "respectful" [body=yes, kind=cnst, prop=no, path="Morphisms", ]; N: 15 "rw" [body=yes, kind=cnst, prop=yes, path="Morph", ]; N: 42 "symmetry" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 16 "trans_sym_co_inv_impl_morphism" [body=yes, kind=cnst, prop=yes, path="Morphisms", ]; N: 40 "trans_sym_co_inv_impl_morphism_obligation_1" [body=yes, kind=cnst, prop=yes, path="Morphisms", ]; N: 44 "transitivity" [body=yes, kind=cnst, prop=yes, path="RelationClasses", ]; N: 26 "Equivalence" [kind=inductive, prop=no, path="RelationClasses", ]; N: 34 "PER" [kind=inductive, prop=no, path="RelationClasses", ]; N: 27 "Build_Equivalence" [kind=construct, prop=yes, path="RelationClasses", ]; N: 35 "Build_PER" [kind=construct, prop=yes, path="RelationClasses", ]; E: 15 16 [weight=1, ]; E: 15 17 [weight=1, ]; E: 15 18 [weight=6, ]; E: 15 19 [weight=5, ]; E: 15 20 [weight=1, ]; E: 15 21 [weight=8, ]; E: 15 22 [weight=1, ]; E: 16 30 [weight=3, ]; E: 16 34 [weight=3, ]; E: 16 36 [weight=1, ]; E: 16 37 [weight=1, ]; E: 16 38 [weight=1, ]; E: 16 39 [weight=1, ]; E: 16 40 [weight=1, ]; E: 17 18 [weight=4, ]; E: 17 19 [weight=1, ]; E: 17 21 [weight=2, ]; E: 17 36 [weight=1, ]; E: 17 37 [weight=1, ]; E: 19 18 [weight=2, ]; E: 20 26 [weight=2, ]; E: 20 30 [weight=2, ]; E: 20 32 [weight=1, ]; E: 20 33 [weight=1, ]; E: 20 34 [weight=1, ]; E: 20 35 [weight=1, ]; E: 21 18 [weight=2, ]; E: 22 18 [weight=2, ]; E: 22 21 [weight=2, ]; E: 22 23 [weight=1, ]; E: 22 24 [weight=1, ]; E: 22 25 [weight=1, ]; E: 22 26 [weight=1, ]; E: 22 27 [weight=1, ]; E: 23 18 [weight=3, ]; E: 23 21 [weight=3, ]; E: 24 18 [weight=1, ]; E: 24 21 [weight=1, ]; E: 25 18 [weight=2, ]; E: 25 21 [weight=2, ]; E: 26 28 [weight=1, ]; E: 26 29 [weight=1, ]; E: 26 30 [weight=1, ]; E: 26 31 [weight=1, ]; E: 27 28 [weight=1, ]; E: 27 29 [weight=1, ]; E: 27 30 [weight=1, ]; E: 27 31 [weight=1, ]; E: 28 30 [weight=2, ]; E: 29 30 [weight=2, ]; E: 31 30 [weight=2, ]; E: 32 26 [weight=3, ]; E: 32 30 [weight=2, ]; E: 32 31 [weight=2, ]; E: 33 26 [weight=3, ]; E: 33 28 [weight=2, ]; E: 33 30 [weight=2, ]; E: 34 28 [weight=1, ]; E: 34 30 [weight=1, ]; E: 34 31 [weight=1, ]; E: 35 28 [weight=1, ]; E: 35 30 [weight=1, ]; E: 35 31 [weight=1, ]; E: 36 30 [weight=2, ]; E: 37 30 [weight=5, ]; E: 40 30 [weight=2, ]; E: 40 34 [weight=2, ]; E: 40 37 [weight=1, ]; E: 40 38 [weight=1, ]; E: 40 39 [weight=1, ]; E: 40 41 [weight=1, ]; E: 40 42 [weight=1, ]; E: 40 43 [weight=1, ]; E: 40 44 [weight=1, ]; E: 41 28 [weight=2, ]; E: 41 30 [weight=2, ]; E: 41 34 [weight=3, ]; E: 42 28 [weight=2, ]; E: 42 30 [weight=2, ]; E: 43 30 [weight=2, ]; E: 43 31 [weight=2, ]; E: 43 34 [weight=3, ]; E: 44 30 [weight=2, ]; E: 44 31 [weight=2, ]; coq-dpdgraph-1.0-8.19/tests/Polymorph.cmd000066400000000000000000000001761457702451100201520ustar00rootroot00000000000000Require Import dpdgraph.dpdgraph. Require Polymorph. Set DependGraph File "Polymorph.dpd". Print DependGraph Polymorph.foo. coq-dpdgraph-1.0-8.19/tests/Polymorph.dot.oracle000066400000000000000000000007361457702451100214430ustar00rootroot00000000000000digraph tests/Polymorph { graph [ratio=0.5] node [style=filled] Polymorph_foo [label="foo", URL=, peripheries=3, fillcolor="#F070D1"] ; _sigT [label="sigT", URL=<.html#sigT>, fillcolor="#E2CDFA"] ; _existT [label="existT", URL=<.html#existT>, fillcolor="#7FAAFF"] ; Polymorph_foo -> _sigT [] ; Polymorph_foo -> _existT [] ; subgraph cluster_Polymorph { label="Polymorph"; fillcolor="#FFFFC3"; labeljust=l; style=filled Polymorph_foo; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/Polymorph.dpd.oracle000066400000000000000000000002761457702451100214230ustar00rootroot00000000000000N: 1 "foo" [body=yes, kind=cnst, prop=no, path="Polymorph", ]; N: 2 "sigT" [kind=inductive, prop=no, ]; N: 3 "existT" [kind=construct, prop=no, ]; E: 1 2 [weight=15, ]; E: 1 3 [weight=2, ]; coq-dpdgraph-1.0-8.19/tests/Polymorph.v000066400000000000000000000003161457702451100176500ustar00rootroot00000000000000Set Universe Polymorphism. Definition foo (A: Type) (B: A -> Type) (C: A -> Type) (c: {x : A & {_ : B x & C x}}) : {x : A & {_ : C x & B x}}. Proof. destruct c as [a [b c]]. exists a, c. exact b. Defined. coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections.cmd000066400000000000000000000003751457702451100223520ustar00rootroot00000000000000Require Import dpdgraph.dpdgraph. Require PrimitiveProjections. Set DependGraph File "PrimitiveProjections.dpd". Print FileDependGraph PrimitiveProjections. Set DependGraph File "PrimitiveProjections2.dpd". Print DependGraph PrimitiveProjections.foo. coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections.dot.oracle000066400000000000000000000030331457702451100236330ustar00rootroot00000000000000digraph tests/PrimitiveProjections { graph [ratio=0.5] node [style=filled] PrimitiveProjections_foo [label="foo", URL=, peripheries=3, fillcolor="#F070D1"] ; PrimitiveProjections_baz [label="baz", URL=, peripheries=3, fillcolor="#F070D1"] ; PrimitiveProjections_bar [label="bar", URL=, peripheries=3, fillcolor="#F070D1"] ; PrimitiveProjections_projT2 [label="projT2", URL=, peripheries=3, fillcolor="#F070D1"] ; PrimitiveProjections_projT1 [label="projT1", URL=, fillcolor="#F070D1"] ; PrimitiveProjections_existT [label="existT", URL=, fillcolor="#7FAAFF"] ; PrimitiveProjections_sigT [label="sigT", URL=, fillcolor="#E2CDFA"] ; PrimitiveProjections_foo -> PrimitiveProjections_existT [] ; PrimitiveProjections_foo -> PrimitiveProjections_sigT [] ; PrimitiveProjections_baz -> PrimitiveProjections_sigT [] ; PrimitiveProjections_bar -> PrimitiveProjections_projT1 [] ; PrimitiveProjections_projT2 -> PrimitiveProjections_sigT [] ; PrimitiveProjections_projT1 -> PrimitiveProjections_sigT [] ; subgraph cluster_PrimitiveProjections { label="PrimitiveProjections"; fillcolor="#FFFFC3"; labeljust=l; style=filled PrimitiveProjections_sigT; PrimitiveProjections_existT; PrimitiveProjections_projT1; PrimitiveProjections_projT2; PrimitiveProjections_bar; PrimitiveProjections_baz; PrimitiveProjections_foo; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections.dpd.oracle000066400000000000000000000012311457702451100236120ustar00rootroot00000000000000N: 3 "bar" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 2 "baz" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 1 "foo" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 5 "projT1" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 4 "projT2" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 7 "sigT" [kind=inductive, prop=no, path="PrimitiveProjections", ]; N: 6 "existT" [kind=construct, prop=no, path="PrimitiveProjections", ]; E: 1 6 [weight=2, ]; E: 1 7 [weight=8, ]; E: 2 7 [weight=2, ]; E: 3 5 [weight=1, ]; E: 3 7 [weight=1, ]; E: 4 7 [weight=2, ]; E: 5 7 [weight=2, ]; coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections.v000066400000000000000000000007621457702451100220540ustar00rootroot00000000000000Set Primitive Projections. Set Implicit Arguments. Record sigT {A} (P : A -> Type) := existT { projT1 : A ; projT2 : P projT1 }. Notation "{ x : A & P }" := (sigT (A:=A) (fun x => P)) : type_scope. Definition bar := @projT1. Definition baz A P (x : @sigT A P) := projT1 x. Definition foo (A: Type) (B: A -> Type) (C: A -> Type) (c: {x : A & {_ : B x & C x}}) : {x : A & {_ : C x & B x}}. Proof. exists (projT1 c). exists (projT2 (projT2 c)). destruct c as [a [b c]]. exact b. Defined. coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections2.dot.oracle000066400000000000000000000013471457702451100237230ustar00rootroot00000000000000digraph tests/PrimitiveProjections2 { graph [ratio=0.5] node [style=filled] PrimitiveProjections_foo [label="foo", URL=, peripheries=3, fillcolor="#F070D1"] ; PrimitiveProjections_sigT [label="sigT", URL=, fillcolor="#E2CDFA"] ; PrimitiveProjections_existT [label="existT", URL=, fillcolor="#7FAAFF"] ; PrimitiveProjections_foo -> PrimitiveProjections_sigT [] ; PrimitiveProjections_foo -> PrimitiveProjections_existT [] ; subgraph cluster_PrimitiveProjections { label="PrimitiveProjections"; fillcolor="#FFFFC3"; labeljust=l; style=filled PrimitiveProjections_existT; PrimitiveProjections_sigT; PrimitiveProjections_foo; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/PrimitiveProjections2.dpd.oracle000066400000000000000000000004041457702451100236750ustar00rootroot00000000000000N: 8 "foo" [body=yes, kind=cnst, prop=no, path="PrimitiveProjections", ]; N: 9 "sigT" [kind=inductive, prop=no, path="PrimitiveProjections", ]; N: 10 "existT" [kind=construct, prop=no, path="PrimitiveProjections", ]; E: 8 9 [weight=8, ]; E: 8 10 [weight=2, ]; coq-dpdgraph-1.0-8.19/tests/Test.cmd000066400000000000000000000002351457702451100170740ustar00rootroot00000000000000Require Import dpdgraph.dpdgraph. Require Test. Print FileDependGraph Test. Set DependGraph File "graph2.dpd". Print DependGraph Test.Permutation_app_swap. coq-dpdgraph-1.0-8.19/tests/Test.v000066400000000000000000001373201457702451100166040ustar00rootroot00000000000000(************************************************************************) (* v * The Coq Proof Assistant / The Coq Development Team *) (* list -> list. Infix "::" := cons (at level 60, right associativity) : list_scope. Open Scope list_scope. (** Head and tail *) Definition head (l:list) := match l with | nil => error | x :: _ => value x end. Definition hd (default:A) (l:list) := match l with | nil => default | x :: _ => x end. Definition tail (l:list) : list := match l with | nil => nil | a :: m => m end. (** Length of lists *) Fixpoint length (l:list) : nat := match l with | nil => 0 | _ :: m => S (length m) end. Parameter size : list -> nat. Axiom size_nil : size nil = 0. (** The [In] predicate *) Fixpoint In (a:A) (l:list) {struct l} : Prop := match l with | nil => False | b :: m => b = a \/ In a m end. (** Concatenation of two lists *) Fixpoint app (l m:list) {struct l} : list := match l with | nil => m | a :: l1 => a :: app l1 m end. Infix "++" := app (right associativity, at level 60) : list_scope. End Lists. (** Exporting list notations and tactics *) Arguments nil {A}. Infix "::" := cons (at level 60, right associativity) : list_scope. Infix "++" := app (right associativity, at level 60) : list_scope. Open Scope list_scope. Delimit Scope list_scope with list. Bind Scope list_scope with list. Arguments list _%_type_scope. (** ** Facts about lists *) Section Facts. Variable A : Type. (** *** Genereric facts *) (** Discrimination *) Theorem nil_cons : forall (x:A) (l:list A), nil <> x :: l. Proof. intros; discriminate. Qed. (** Destruction *) Theorem destruct_list : forall l : list A, {x:A & {tl:list A | l = x::tl}}+{l = nil}. Proof. induction l as [|a tl]. right; reflexivity. left; exists a; exists tl; reflexivity. Qed. (** *** Head and tail *) Theorem head_nil : head (@nil A) = None. Proof. simpl; reflexivity. Qed. Theorem head_cons : forall (l : list A) (x : A), head (x::l) = Some x. Proof. intros; simpl; reflexivity. Qed. (************************) (** *** Facts about [In] *) (************************) (** Characterization of [In] *) Theorem in_eq : forall (a:A) (l:list A), In a (a :: l). Proof. simpl in |- *; auto. Qed. Theorem in_cons : forall (a b:A) (l:list A), In b l -> In b (a :: l). Proof. simpl in |- *; auto. Qed. Theorem in_nil : forall a:A, ~ In a nil. Proof. unfold not in |- *; intros a H; inversion_clear H. Qed. Lemma In_split : forall x (l:list A), In x l -> exists l1, exists l2, l = l1++x::l2. Proof. induction l; simpl; destruct 1. subst a; auto. exists (@nil A); exists l; auto. destruct (IHl H) as (l1,(l2,H0)). exists (a::l1); exists l2; simpl; f_equal; auto. Qed. (** Inversion *) Theorem in_inv : forall (a b:A) (l:list A), In b (a :: l) -> a = b \/ In b l. Proof. intros a b l H; inversion_clear H; auto. Qed. (** Decidability of [In] *) Theorem In_dec : (forall x y:A, {x = y} + {x <> y}) -> forall (a:A) (l:list A), {In a l} + {~ In a l}. Proof. intro H; induction l as [| a0 l IHl]. right; apply in_nil. destruct (H a0 a); simpl in |- *; auto. destruct IHl; simpl in |- *; auto. right; unfold not in |- *; intros [Hc1| Hc2]; auto. Defined. (*************************) (** *** Facts about [app] *) (*************************) (** Discrimination *) Theorem app_cons_not_nil : forall (x y:list A) (a:A), nil <> x ++ a :: y. Proof. unfold not in |- *. destruct x as [| a l]; simpl in |- *; intros. discriminate H. discriminate H. Qed. (** Concat with [nil] *) Theorem app_nil_end : forall l:list A, l = l ++ nil. Proof. induction l; simpl in |- *; auto. rewrite <- IHl; auto. Qed. (** [app] is associative *) Theorem app_ass : forall l m n:list A, (l ++ m) ++ n = l ++ m ++ n. Proof. intros. induction l; simpl in |- *; auto. now_show (a :: (l ++ m) ++ n = a :: l ++ m ++ n). rewrite <- IHl; auto. Qed. Hint Resolve app_ass : core. Theorem ass_app : forall l m n:list A, l ++ m ++ n = (l ++ m) ++ n. Proof. auto using app_ass. Qed. (** [app] commutes with [cons] *) Theorem app_comm_cons : forall (x y:list A) (a:A), a :: (x ++ y) = (a :: x) ++ y. Proof. auto. Qed. (** Facts deduced from the result of a concatenation *) Theorem app_eq_nil : forall l l':list A, l ++ l' = nil -> l = nil /\ l' = nil. Proof. destruct l as [| x l]; destruct l' as [| y l']; simpl in |- *; auto. intro; discriminate. intros H; discriminate H. Qed. Theorem app_eq_unit : forall (x y:list A) (a:A), x ++ y = a :: nil -> x = nil /\ y = a :: nil \/ x = a :: nil /\ y = nil. Proof. destruct x as [| a l]; [ destruct y as [| a l] | destruct y as [| a0 l0] ]; simpl in |- *. intros a H; discriminate H. left; split; auto. right; split; auto. generalize H. generalize (app_nil_end l); intros E. rewrite <- E; auto. intros. injection H. intro. cut (nil = l ++ a0 :: l0); auto. intro. generalize (app_cons_not_nil _ _ _ H1); intro. elim H2. Qed. Lemma app_inj_tail : forall (x y:list A) (a b:A), x ++ a :: nil = y ++ b :: nil -> x = y /\ a = b. Proof. induction x as [| x l IHl]; [ destruct y as [| a l] | destruct y as [| a l0] ]; simpl in |- *; auto. intros a b H. injection H. auto. intros a0 b H. injection H; intros. generalize (app_cons_not_nil _ _ _ H0); destruct 1. intros a b H. injection H; intros. cut (nil = l ++ a :: nil); auto. intro. generalize (app_cons_not_nil _ _ _ H2); destruct 1. intros a0 b H. injection H; intros. destruct (IHl l0 a0 b H0). split; auto. rewrite <- H1; rewrite <- H2; reflexivity. Qed. (** Compatibility wtih other operations *) Lemma app_length : forall l l' : list A, length (l++l') = length l + length l'. Proof. induction l; simpl; auto. Qed. Lemma in_app_or : forall (l m:list A) (a:A), In a (l ++ m) -> In a l \/ In a m. Proof. intros l m a. elim l; simpl in |- *; auto. intros a0 y H H0. now_show ((a0 = a \/ In a y) \/ In a m). elim H0; auto. intro H1. now_show ((a0 = a \/ In a y) \/ In a m). elim (H H1); auto. Qed. Lemma in_or_app : forall (l m:list A) (a:A), In a l \/ In a m -> In a (l ++ m). Proof. intros l m a. elim l; simpl in |- *; intro H. now_show (In a m). elim H; auto; intro H0. now_show (In a m). elim H0. (* subProof completed *) intros y H0 H1. now_show (H = a \/ In a (y ++ m)). elim H1; auto 4. intro H2. now_show (H = a \/ In a (y ++ m)). elim H2; auto. Qed. Lemma app_inv_head: forall l l1 l2 : list A, l ++ l1 = l ++ l2 -> l1 = l2. Proof. induction l; simpl; auto; injection 1; auto. Qed. Lemma app_inv_tail: forall l l1 l2 : list A, l1 ++ l = l2 ++ l -> l1 = l2. Proof. intros l l1 l2; revert l1 l2 l. induction l1 as [ | x1 l1]; destruct l2 as [ | x2 l2]; simpl; auto; intros l H. absurd (length (x2 :: l2 ++ l) <= length l). simpl; rewrite app_length; auto with arith. rewrite <- H; auto with arith. absurd (length (x1 :: l1 ++ l) <= length l). simpl; rewrite app_length; auto with arith. rewrite H; auto with arith. injection H; clear H; intros; f_equal; eauto. Qed. End Facts. #[global] Hint Resolve app_nil_end ass_app app_ass: datatypes v62. #[global] Hint Resolve app_comm_cons app_cons_not_nil: datatypes v62. #[global] Hint Immediate app_eq_nil: datatypes v62. #[global] Hint Resolve app_eq_unit app_inj_tail: datatypes v62. #[global] Hint Resolve in_eq in_cons in_inv in_nil in_app_or in_or_app: datatypes v62. (*******************************************) (** * Operations on the elements of a list *) (*******************************************) Section Elts. Variable A : Type. (*****************************) (** ** Nth element of a list *) (*****************************) Fixpoint nth (n:nat) (l:list A) (default:A) {struct l} : A := match n, l with | O, x :: l' => x | O, _other => default | S m, nil => default | S m, x :: t => nth m t default end. Fixpoint nth_ok (n:nat) (l:list A) (default:A) {struct l} : bool := match n, l with | O, x :: l' => true | O, _other => false | S m, nil => false | S m, x :: t => nth_ok m t default end. Lemma nth_in_or_default : forall (n:nat) (l:list A) (d:A), {In (nth n l d) l} + {nth n l d = d}. (* Realizer nth_ok. Program_all. *) Proof. intros n l d; generalize n; induction l; intro n0. right; case n0; trivial. case n0; simpl in |- *. auto. intro n1; elim (IHl n1); auto. Qed. Lemma nth_S_cons : forall (n:nat) (l:list A) (d a:A), In (nth n l d) l -> In (nth (S n) (a :: l) d) (a :: l). Proof. simpl in |- *; auto. Qed. Fixpoint nth_error (l:list A) (n:nat) {struct n} : Exc A := match n, l with | O, x :: _ => value x | S n, _ :: l => nth_error l n | _, _ => error end. Definition nth_default (default:A) (l:list A) (n:nat) : A := match nth_error l n with | Some x => x | None => default end. Lemma nth_In : forall (n:nat) (l:list A) (d:A), n < length l -> In (nth n l d) l. Proof. unfold lt in |- *; induction n as [| n hn]; simpl in |- *. destruct l; simpl in |- *; [ inversion 2 | auto ]. destruct l as [| a l]; simpl in |- *. inversion 2. intros d ie; right; apply hn; auto with arith. Qed. Lemma nth_overflow : forall l n d, length l <= n -> nth n l d = d. Proof. induction l; destruct n; simpl; intros; auto. inversion H. apply IHl; auto with arith. Qed. Lemma nth_indep : forall l n d d', n < length l -> nth n l d = nth n l d'. Proof. induction l; simpl; intros; auto. inversion H. destruct n; simpl; auto with arith. Qed. Lemma app_nth1 : forall l l' d n, n < length l -> nth n (l++l') d = nth n l d. Proof. induction l. intros. inversion H. intros l' d n. case n; simpl; auto. intros; rewrite IHl; auto with arith. Qed. Lemma app_nth2 : forall l l' d n, n >= length l -> nth n (l++l') d = nth (n-length l) l' d. Proof. induction l. intros. simpl. destruct n; auto. intros l' d n. case n; simpl; auto. intros. inversion H. intros. rewrite IHl; auto with arith. Qed. (*****************) (** ** Remove *) (*****************) Section Remove. Hypothesis eq_dec : forall x y : A, {x = y}+{x <> y}. Fixpoint remove (x : A) (l : list A){struct l} : list A := match l with | nil => nil | y::tl => if (eq_dec x y) then remove x tl else y::(remove x tl) end. Theorem remove_In : forall (l : list A) (x : A), ~ In x (remove x l). Proof. induction l as [|x l]; auto. intro y; simpl; destruct (eq_dec y x) as [yeqx | yneqx]. apply IHl. unfold not; intro HF; simpl in HF; destruct HF; auto. apply (IHl y); assumption. Qed. End Remove. (******************************) (** ** Last element of a list *) (******************************) (** [last l d] returns the last element of the list [l], or the default value [d] if [l] is empty. *) Fixpoint last (l:list A) (d:A) {struct l} : A := match l with | nil => d | a :: nil => a | a :: l => last l d end. (** [removelast l] remove the last element of [l] *) Fixpoint removelast (l:list A) {struct l} : list A := match l with | nil => nil | a :: nil => nil | a :: l => a :: removelast l end. Lemma app_removelast_last : forall l d, l<>nil -> l = removelast l ++ (last l d :: nil). Proof. induction l. destruct 1; auto. intros d _. destruct l; auto. pattern (a0::l) at 1; rewrite IHl with d; auto; discriminate. Qed. Lemma exists_last : forall l, l<>nil -> { l' : (list A) & { a : A | l = l'++a::nil}}. Proof. induction l. destruct 1; auto. intros _. destruct l. exists (@nil A); exists a; auto. destruct IHl as [l' (a',H)]; try discriminate. rewrite H. exists (a::l'); exists a'; auto. Qed. Lemma removelast_app : forall l l', l' <> nil -> removelast (l++l') = l ++ removelast l'. Proof. induction l. simpl; auto. simpl; intros. assert (l++l' <> nil). destruct l. simpl; auto. simpl; discriminate. specialize (IHl l' H). destruct (l++l'); [elim H0; auto|f_equal; auto]. Qed. (****************************************) (** ** Counting occurences of a element *) (****************************************) Hypotheses eqA_dec : forall x y : A, {x = y}+{x <> y}. Fixpoint count_occ (l : list A) (x : A){struct l} : nat := match l with | nil => 0 | y :: tl => let n := count_occ tl x in if eqA_dec y x then S n else n end. (** Compatibility of count_occ with operations on list *) Theorem count_occ_In : forall (l : list A) (x : A), In x l <-> count_occ l x > 0. Proof. induction l as [|y l]. simpl; intros; split; [destruct 1 | apply Nat.lt_irrefl]. simpl. intro x; destruct (eqA_dec y x) as [Heq|Hneq]. rewrite Heq; intuition auto with *. pose (IHl x). intuition auto with *. Qed. Theorem count_occ_inv_nil : forall (l : list A), (forall x:A, count_occ l x = 0) <-> l = nil. Proof. split. (* Case -> *) induction l as [|x l]. trivial. intro H. elim (O_S (count_occ l x)). apply sym_eq. generalize (H x). simpl. destruct (eqA_dec x x) as [|HF]. trivial. elim HF; reflexivity. (* Case <- *) intro H; rewrite H; simpl; reflexivity. Qed. Lemma count_occ_nil : forall (x : A), count_occ nil x = 0. Proof. intro x; simpl; reflexivity. Qed. Lemma count_occ_cons_eq : forall (l : list A) (x y : A), x = y -> count_occ (x::l) y = S (count_occ l y). Proof. intros l x y H; simpl. destruct (eqA_dec x y); [reflexivity | contradiction]. Qed. Lemma count_occ_cons_neq : forall (l : list A) (x y : A), x <> y -> count_occ (x::l) y = count_occ l y. Proof. intros l x y H; simpl. destruct (eqA_dec x y); [contradiction | reflexivity]. Qed. End Elts. (*******************************) (** * Manipulating whole lists *) (*******************************) Section ListOps. Variable A : Type. (*************************) (** ** Reverse *) (*************************) Fixpoint rev (l:list A) : list A := match l with | nil => nil | x :: l' => rev l' ++ x :: nil end. Lemma distr_rev : forall x y:list A, rev (x ++ y) = rev y ++ rev x. Proof. induction x as [| a l IHl]. destruct y as [| a l]. simpl in |- *. auto. simpl in |- *. apply app_nil_end; auto. intro y. simpl in |- *. rewrite (IHl y). apply (app_ass (rev y) (rev l) (a :: nil)). Qed. Remark rev_unit : forall (l:list A) (a:A), rev (l ++ a :: nil) = a :: rev l. Proof. intros. apply (distr_rev l (a :: nil)); simpl in |- *; auto. Qed. Lemma rev_involutive : forall l:list A, rev (rev l) = l. Proof. induction l as [| a l IHl]. simpl in |- *; auto. simpl in |- *. rewrite (rev_unit (rev l) a). rewrite IHl; auto. Qed. (** Compatibility with other operations *) Lemma In_rev : forall l x, In x l <-> In x (rev l). Proof. induction l. simpl; intuition. intros. simpl. intuition. subst. apply in_or_app; right; simpl; auto. apply in_or_app; left; firstorder. destruct (in_app_or _ _ _ H); firstorder. Qed. Lemma rev_length : forall l, length (rev l) = length l. Proof. induction l;simpl; auto. rewrite app_length. rewrite IHl. simpl. elim (length l); simpl; auto. Qed. Lemma rev_nth : forall l d n, n < length l -> nth n (rev l) d = nth (length l - S n) l d. Proof. induction l. intros; inversion H. intros. simpl in H. simpl (rev (a :: l)). simpl (length (a :: l) - S n). inversion H. rewrite Nat.sub_diag; simpl. rewrite <- rev_length. rewrite app_nth2; auto. rewrite Nat.sub_diag; auto. rewrite app_nth1 by (rewrite rev_length; exact H1). rewrite <-Nat.sub_succ, Nat.sub_succ_l by (exact H1). apply IHl; exact H1. Qed. (** An alternative tail-recursive definition for reverse *) Fixpoint rev_append (l l': list A) {struct l} : list A := match l with | nil => l' | a::l => rev_append l (a::l') end. Definition rev' l : list A := rev_append l nil. Notation rev_acc := rev_append (only parsing). Lemma rev_append_rev : forall l l', rev_acc l l' = rev l ++ l'. Proof. induction l; simpl; auto; intros. rewrite <- ass_app; firstorder. Qed. Notation rev_acc_rev := rev_append_rev (only parsing). Lemma rev_alt : forall l, rev l = rev_append l nil. Proof. intros; rewrite rev_append_rev. apply app_nil_end. Qed. (*********************************************) (** Reverse Induction Principle on Lists *) (*********************************************) Section Reverse_Induction. Unset Implicit Arguments. Lemma rev_list_ind : forall P:list A-> Prop, P nil -> (forall (a:A) (l:list A), P (rev l) -> P (rev (a :: l))) -> forall l:list A, P (rev l). Proof. induction l; auto. Qed. Set Implicit Arguments. Theorem rev_ind : forall P:list A -> Prop, P nil -> (forall (x:A) (l:list A), P l -> P (l ++ x :: nil)) -> forall l:list A, P l. Proof. intros. generalize (rev_involutive l). intros E; rewrite <- E. apply (rev_list_ind P). auto. simpl in |- *. intros. apply (H0 a (rev l0)). auto. Qed. End Reverse_Induction. (***********************************) (** ** Lists modulo permutation *) (***********************************) Section Permutation. Inductive Permutation : list A -> list A -> Prop := | perm_nil: Permutation nil nil | perm_skip: forall (x:A) (l l':list A), Permutation l l' -> Permutation (cons x l) (cons x l') | perm_swap: forall (x y:A) (l:list A), Permutation (cons y (cons x l)) (cons x (cons y l)) | perm_trans: forall (l l' l'':list A), Permutation l l' -> Permutation l' l'' -> Permutation l l''. Hint Constructors Permutation : core. (** Some facts about [Permutation] *) Theorem Permutation_nil : forall (l : list A), Permutation nil l -> l = nil. Proof. intros l HF. set (m:=@nil A) in HF; assert (m = nil); [reflexivity|idtac]; clearbody m. induction HF; try elim (nil_cons (sym_eq H)); auto. Qed. Theorem Permutation_nil_cons : forall (l : list A) (x : A), ~ Permutation nil (x::l). Proof. unfold not; intros l x HF. elim (@nil_cons A x l). apply sym_eq. exact (Permutation_nil HF). Qed. (** Permutation over lists is a equivalence relation *) Theorem Permutation_refl : forall l : list A, Permutation l l. Proof. induction l; constructor. exact IHl. Qed. Theorem Permutation_sym : forall l l' : list A, Permutation l l' -> Permutation l' l. Proof. intros l l' Hperm; induction Hperm; auto. apply perm_trans with (l':=l'); assumption. Qed. Theorem Permutation_trans : forall l l' l'' : list A, Permutation l l' -> Permutation l' l'' -> Permutation l l''. Proof. exact perm_trans. Qed. Hint Resolve Permutation_refl Permutation_sym Permutation_trans : core. (** Compatibility with others operations on lists *) Theorem Permutation_in : forall (l l' : list A) (x : A), Permutation l l' -> In x l -> In x l'. Proof. intros l l' x Hperm; induction Hperm; simpl; tauto. Qed. Lemma Permutation_app_tail : forall (l l' tl : list A), Permutation l l' -> Permutation (l++tl) (l'++tl). Proof. intros l l' tl Hperm; induction Hperm as [|x l l'|x y l|l l' l'']; simpl; auto. eapply Permutation_trans with (l':=l'++tl); trivial. Qed. Lemma Permutation_app_head : forall (l tl tl' : list A), Permutation tl tl' -> Permutation (l++tl) (l++tl'). Proof. intros l tl tl' Hperm; induction l; [trivial | repeat rewrite <- app_comm_cons; constructor; assumption]. Qed. Theorem Permutation_app : forall (l m l' m' : list A), Permutation l l' -> Permutation m m' -> Permutation (l++m) (l'++m'). Proof. intros l m l' m' Hpermll' Hpermmm'; induction Hpermll' as [|x l l'|x y l|l l' l'']; repeat rewrite <- app_comm_cons; auto. apply Permutation_trans with (l' := (x :: y :: l ++ m)); [idtac | repeat rewrite app_comm_cons; apply Permutation_app_head]; trivial. apply Permutation_trans with (l' := (l' ++ m')); try assumption. apply Permutation_app_tail; assumption. Qed. Theorem Permutation_app_swap : forall (l l' : list A), Permutation (l++l') (l'++l). Proof. induction l as [|x l]. simpl; intro l'; rewrite <- app_nil_end; trivial. induction l' as [|y l']. simpl; rewrite <- app_nil_end; trivial. simpl; apply Permutation_trans with (l' := x :: y :: l' ++ l). constructor; rewrite app_comm_cons; apply IHl. apply Permutation_trans with (l' := y :: x :: l' ++ l); constructor. apply Permutation_trans with (l' := x :: l ++ l'); auto. Qed. Theorem Permutation_cons_app : forall (l l1 l2:list A) a, Permutation l (l1 ++ l2) -> Permutation (a :: l) (l1 ++ a :: l2). Proof. intros l l1; revert l. induction l1. simpl. intros; apply perm_skip; auto. simpl; intros. apply perm_trans with (a0::a::l1++l2). apply perm_skip; auto. apply perm_trans with (a::a0::l1++l2). apply perm_swap; auto. apply perm_skip; auto. Qed. Hint Resolve Permutation_cons_app : core. Theorem Permutation_length : forall (l l' : list A), Permutation l l' -> length l = length l'. Proof. intros l l' Hperm; induction Hperm; simpl; auto. apply trans_eq with (y:= (length l')); trivial. Qed. Theorem Permutation_rev : forall (l : list A), Permutation l (rev l). Proof. induction l as [| x l]; simpl; trivial. apply Permutation_trans with (l' := (x::nil)++rev l). simpl; auto. apply Permutation_app_swap. Qed. Theorem Permutation_ind_bis : forall P : list A -> list A -> Prop, P (@nil A) (@nil A) -> (forall x l l', Permutation l l' -> P l l' -> P (x :: l) (x :: l')) -> (forall x y l l', Permutation l l' -> P l l' -> P (y :: x :: l) (x :: y :: l')) -> (forall l l' l'', Permutation l l' -> P l l' -> Permutation l' l'' -> P l' l'' -> P l l'') -> forall l l', Permutation l l' -> P l l'. Proof. intros P Hnil Hskip Hswap Htrans. induction 1; auto. apply Htrans with (x::y::l); auto. apply Hswap; auto. induction l; auto. apply Hskip; auto. apply Hskip; auto. induction l; auto. eauto. Qed. Ltac break_list l x l' H := destruct l as [|x l']; simpl in *; injection H; intros; subst; clear H. Theorem Permutation_app_inv : forall (l1 l2 l3 l4:list A) a, Permutation (l1++a::l2) (l3++a::l4) -> Permutation (l1++l2) (l3 ++ l4). Proof. set (P:=fun l l' => forall a l1 l2 l3 l4, l=l1++a::l2 -> l'=l3++a::l4 -> Permutation (l1++l2) (l3++l4)). cut (forall l l', Permutation l l' -> P l l'). intros; apply (H _ _ H0 a); auto. intros; apply (Permutation_ind_bis P); unfold P; clear P; try clear H l l'; simpl; auto. (* nil *) intros; destruct l1; simpl in *; discriminate. (* skip *) intros x l l' H IH; intros. break_list l1 b l1' H0; break_list l3 c l3' H1. auto. apply perm_trans with (l3'++c::l4); auto. apply perm_trans with (l1'++a::l2); auto using Permutation_cons_app. apply perm_skip. apply (IH a l1' l2 l3' l4); auto. (* contradict *) intros x y l l' Hp IH; intros. break_list l1 b l1' H; break_list l3 c l3' H0. auto. break_list l3' b l3'' H. auto. apply perm_trans with (c::l3''++b::l4); auto. break_list l1' c l1'' H1. auto. apply perm_trans with (b::l1''++c::l2); auto. break_list l3' d l3'' H; break_list l1' e l1'' H1. auto. apply perm_trans with (e::a::l1''++l2); auto. apply perm_trans with (e::l1''++a::l2); auto. apply perm_trans with (d::a::l3''++l4); auto. apply perm_trans with (d::l3''++a::l4); auto. apply perm_trans with (e::d::l1''++l2); auto. apply perm_skip; apply perm_skip. apply (IH a l1'' l2 l3'' l4); auto. (*trans*) intros. destruct (In_split a l') as (l'1,(l'2,H6)). apply (Permutation_in a H). subst l. apply in_or_app; right; red; auto. apply perm_trans with (l'1++l'2). apply (H0 _ _ _ _ _ H3 H6). apply (H2 _ _ _ _ _ H6 H4). Qed. Theorem Permutation_cons_inv : forall l l' a, Permutation (a::l) (a::l') -> Permutation l l'. Proof. intros; exact (Permutation_app_inv (@nil _) l (@nil _) l' a H). Qed. Theorem Permutation_cons_app_inv : forall l l1 l2 a, Permutation (a :: l) (l1 ++ a :: l2) -> Permutation l (l1 ++ l2). Proof. intros; exact (Permutation_app_inv (@nil _) l l1 l2 a H). Qed. Theorem Permutation_app_inv_l : forall l l1 l2, Permutation (l ++ l1) (l ++ l2) -> Permutation l1 l2. Proof. induction l; simpl; auto. intros. apply IHl. apply Permutation_cons_inv with a; auto. Qed. Theorem Permutation_app_inv_r : forall l l1 l2, Permutation (l1 ++ l) (l2 ++ l) -> Permutation l1 l2. Proof. induction l. intros l1 l2; do 2 rewrite <- app_nil_end; auto. intros. apply IHl. apply Permutation_app_inv with a; auto. Qed. End Permutation. (***********************************) (** ** Decidable equality on lists *) (***********************************) Hypotheses eqA_dec : forall (x y : A), {x = y}+{x <> y}. Lemma list_eq_dec : forall l l':list A, {l = l'} + {l <> l'}. Proof. induction l as [| x l IHl]; destruct l' as [| y l']. left; trivial. right; apply nil_cons. right; unfold not; intro HF; apply (nil_cons (sym_eq HF)). destruct (eqA_dec x y) as [xeqy|xneqy]; destruct (IHl l') as [leql'|lneql']; try (right; unfold not; intro HF; injection HF; intros; contradiction). rewrite xeqy; rewrite leql'; left; trivial. Qed. End ListOps. (***************************************************) (** * Applying functions to the elements of a list *) (***************************************************) (************) (** ** Map *) (************) Section Map. Variables A B : Type. Variable f : A -> B. Fixpoint map (l:list A) : list B := match l with | nil => nil | cons a t => cons (f a) (map t) end. Lemma in_map : forall (l:list A) (x:A), In x l -> In (f x) (map l). Proof. induction l as [| a l IHl]; simpl in |- *; [ auto | destruct 1; [ left; apply f_equal with (f := f); assumption | auto ] ]. Qed. Lemma in_map_iff : forall l y, In y (map l) <-> exists x, f x = y /\ In x l. Proof. induction l; firstorder (subst; auto). Qed. Lemma map_length : forall l, length (map l) = length l. Proof. induction l; simpl; auto. Qed. Lemma map_nth : forall l d n, nth n (map l) (f d) = f (nth n l d). Proof. induction l; simpl map; destruct n; firstorder. Qed. Lemma map_app : forall l l', map (l++l') = (map l)++(map l'). Proof. induction l; simpl; auto. intros; rewrite IHl; auto. Qed. Lemma map_rev : forall l, map (rev l) = rev (map l). Proof. induction l; simpl; auto. rewrite map_app. rewrite IHl; auto. Qed. Hint Constructors Permutation : core. Lemma Permutation_map : forall l l', Permutation l l' -> Permutation (map l) (map l'). Proof. induction 1; simpl; auto; eauto. Qed. (** [flat_map] *) Fixpoint flat_map (f:A -> list B) (l:list A) {struct l} : list B := match l with | nil => nil | cons x t => (f x)++(flat_map f t) end. Lemma in_flat_map : forall (f:A->list B)(l:list A)(y:B), In y (flat_map f l) <-> exists x, In x l /\ In y (f x). Proof. induction l; simpl; split; intros. contradiction. destruct H as (x,(H,_)); contradiction. destruct (in_app_or _ _ _ H). exists a; auto. destruct (IHl y) as (H1,_); destruct (H1 H0) as (x,(H2,H3)). exists x; auto. apply in_or_app. destruct H as (x,(H0,H1)); destruct H0. subst; auto. right; destruct (IHl y) as (_,H2); apply H2. exists x; auto. Qed. End Map. Lemma map_map : forall (A B C:Type)(f:A->B)(g:B->C) l, map g (map f l) = map (fun x => g (f x)) l. Proof. induction l; simpl; auto. rewrite IHl; auto. Qed. Lemma map_ext : forall (A B : Type)(f g:A->B), (forall a, f a = g a) -> forall l, map f l = map g l. Proof. induction l; simpl; auto. rewrite H; rewrite IHl; auto. Qed. (************************************) (** Left-to-right iterator on lists *) (************************************) Section Fold_Left_Recursor. Variables A B : Type. Variable f : A -> B -> A. Fixpoint fold_left (l:list B) (a0:A) {struct l} : A := match l with | nil => a0 | cons b t => fold_left t (f a0 b) end. Lemma fold_left_app : forall (l l':list B)(i:A), fold_left (l++l') i = fold_left l' (fold_left l i). Proof. induction l. simpl; auto. intros. simpl. auto. Qed. End Fold_Left_Recursor. Lemma fold_left_length : forall (A:Type)(l:list A), fold_left (fun x _ => S x) l 0 = length l. Proof. intro A. cut (forall (l:list A) n, fold_left (fun x _ => S x) l n = n + length l). intros. exact (H l 0). induction l; simpl; auto. intros; rewrite IHl. simpl; auto with arith. Qed. (************************************) (** Right-to-left iterator on lists *) (************************************) Section Fold_Right_Recursor. Variables A B : Type. Variable f : B -> A -> A. Variable a0 : A. Fixpoint fold_right (l:list B) : A := match l with | nil => a0 | cons b t => f b (fold_right t) end. End Fold_Right_Recursor. Lemma fold_right_app : forall (A B:Type)(f:A->B->B) l l' i, fold_right f i (l++l') = fold_right f (fold_right f i l') l. Proof. induction l. simpl; auto. simpl; intros. f_equal; auto. Qed. Lemma fold_left_rev_right : forall (A B:Type)(f:A->B->B) l i, fold_right f i (rev l) = fold_left (fun x y => f y x) l i. Proof. induction l. simpl; auto. intros. simpl. rewrite fold_right_app; simpl; auto. Qed. Theorem fold_symmetric : forall (A:Type) (f:A -> A -> A), (forall x y z:A, f x (f y z) = f (f x y) z) -> (forall x y:A, f x y = f y x) -> forall (a0:A) (l:list A), fold_left f l a0 = fold_right f a0 l. Proof. destruct l as [| a l]. reflexivity. simpl in |- *. rewrite <- H0. generalize a0 a. induction l as [| a3 l IHl]; simpl in |- *. trivial. intros. rewrite H. rewrite (H0 a2). rewrite <- (H a1). rewrite (H0 a1). rewrite IHl. reflexivity. Qed. (** [(list_power x y)] is [y^x], or the set of sequences of elts of [y] indexed by elts of [x], sorted in lexicographic order. *) Fixpoint list_power (A B:Type)(l:list A) (l':list B) {struct l} : list (list (A * B)) := match l with | nil => cons nil nil | cons x t => flat_map (fun f:list (A * B) => map (fun y:B => cons (x, y) f) l') (list_power t l') end. (*************************************) (** ** Boolean operations over lists *) (*************************************) Section Bool. Variable A : Type. Variable f : A -> bool. (** find whether a boolean function can be satisfied by an elements of the list. *) Fixpoint existsb (l:list A) {struct l}: bool := match l with | nil => false | a::l => f a || existsb l end. Lemma existsb_exists : forall l, existsb l = true <-> exists x, In x l /\ f x = true. Proof. induction l; simpl; intuition. inversion H. firstorder. destruct (orb_prop _ _ H1); firstorder. firstorder auto with bool. subst. rewrite H2; auto. Qed. Lemma existsb_nth : forall l n d, n < length l -> existsb l = false -> f (nth n l d) = false. Proof. induction l. inversion 1. simpl; intros. destruct (orb_false_elim _ _ H0); clear H0; auto. destruct n ; auto. rewrite IHl; auto with arith. Qed. (** find whether a boolean function is satisfied by all the elements of a list. *) Fixpoint forallb (l:list A) {struct l} : bool := match l with | nil => true | a::l => f a && forallb l end. Lemma forallb_forall : forall l, forallb l = true <-> (forall x, In x l -> f x = true). Proof. induction l; simpl; intuition. destruct (andb_prop _ _ H1). congruence. destruct (andb_prop _ _ H1); auto. assert (forallb l = true). apply H0; intuition. rewrite H1; auto. Qed. (** [filter] *) Fixpoint filter (l:list A) : list A := match l with | nil => nil | x :: l => if f x then x::(filter l) else filter l end. Lemma filter_In : forall x l, In x (filter l) <-> In x l /\ f x = true. Proof. induction l; simpl. intuition. intros. case_eq (f a); intros; simpl; intuition congruence. Qed. (** [find] *) Fixpoint find (l:list A) : option A := match l with | nil => None | x :: tl => if f x then Some x else find tl end. (** [partition] *) Fixpoint partition (l:list A) {struct l} : list A * list A := match l with | nil => (nil, nil) | x :: tl => let (g,d) := partition tl in if f x then (x::g,d) else (g,x::d) end. End Bool. (******************************************************) (** ** Operations on lists of pairs or lists of lists *) (******************************************************) Section ListPairs. Variables A B : Type. (** [split] derives two lists from a list of pairs *) Fixpoint split (l:list (A*B)) { struct l }: list A * list B := match l with | nil => (nil, nil) | (x,y) :: tl => let (g,d) := split tl in (x::g, y::d) end. Lemma in_split_l : forall (l:list (A*B))(p:A*B), In p l -> In (fst p) (fst (split l)). Proof. induction l; simpl; intros; auto. destruct p; destruct a; destruct (split l); simpl in *. destruct H. injection H; auto. right; apply (IHl (a0,b) H). Qed. Lemma in_split_r : forall (l:list (A*B))(p:A*B), In p l -> In (snd p) (snd (split l)). Proof. induction l; simpl; intros; auto. destruct p; destruct a; destruct (split l); simpl in *. destruct H. injection H; auto. right; apply (IHl (a0,b) H). Qed. Lemma split_nth : forall (l:list (A*B))(n:nat)(d:A*B), nth n l d = (nth n (fst (split l)) (fst d), nth n (snd (split l)) (snd d)). Proof. induction l. destruct n; destruct d; simpl; auto. destruct n; destruct d; simpl; auto. destruct a; destruct (split l); simpl; auto. destruct a; destruct (split l); simpl in *. apply IHl. Qed. Lemma split_length_l : forall (l:list (A*B)), length (fst (split l)) = length l. Proof. induction l; simpl; auto. destruct a; destruct (split l); simpl; auto. Qed. Lemma split_length_r : forall (l:list (A*B)), length (snd (split l)) = length l. Proof. induction l; simpl; auto. destruct a; destruct (split l); simpl; auto. Qed. (** [combine] is the opposite of [split]. Lists given to [combine] are meant to be of same length. If not, [combine] stops on the shorter list *) Fixpoint combine (l : list A) (l' : list B){struct l} : list (A*B) := match l,l' with | x::tl, y::tl' => (x,y)::(combine tl tl') | _, _ => nil end. Lemma split_combine : forall (l: list (A*B)), let (l1,l2) := split l in combine l1 l2 = l. Proof. induction l. simpl; auto. destruct a; simpl. destruct (split l); simpl in *. f_equal; auto. Qed. Lemma combine_split : forall (l:list A)(l':list B), length l = length l' -> split (combine l l') = (l,l'). Proof. induction l; destruct l'; simpl; intros; auto; try discriminate. injection H; clear H; intros. rewrite IHl; auto. Qed. Lemma in_combine_l : forall (l:list A)(l':list B)(x:A)(y:B), In (x,y) (combine l l') -> In x l. Proof. induction l. simpl; auto. destruct l'; simpl; auto; intros. contradiction. destruct H. injection H; auto. right; apply IHl with l' y; auto. Qed. Lemma in_combine_r : forall (l:list A)(l':list B)(x:A)(y:B), In (x,y) (combine l l') -> In y l'. Proof. induction l. simpl; intros; contradiction. destruct l'; simpl; auto; intros. destruct H. injection H; auto. right; apply IHl with x; auto. Qed. Lemma combine_length : forall (l:list A)(l':list B), length (combine l l') = min (length l) (length l'). Proof. induction l. simpl; auto. destruct l'; simpl; auto. Qed. Lemma combine_nth : forall (l:list A)(l':list B)(n:nat)(x:A)(y:B), length l = length l' -> nth n (combine l l') (x,y) = (nth n l x, nth n l' y). Proof. induction l; destruct l'; intros; try discriminate. destruct n; simpl; auto. destruct n; simpl in *; auto. Qed. (** [list_prod] has the same signature as [combine], but unlike [combine], it adds every possible pairs, not only those at the same position. *) Fixpoint list_prod (l:list A) (l':list B) {struct l} : list (A * B) := match l with | nil => nil | cons x t => (map (fun y:B => (x, y)) l')++(list_prod t l') end. Lemma in_prod_aux : forall (x:A) (y:B) (l:list B), In y l -> In (x, y) (map (fun y0:B => (x, y0)) l). Proof. induction l; [ simpl in |- *; auto | simpl in |- *; destruct 1 as [H1| ]; [ left; rewrite H1; trivial | right; auto ] ]. Qed. Lemma in_prod : forall (l:list A) (l':list B) (x:A) (y:B), In x l -> In y l' -> In (x, y) (list_prod l l'). Proof. induction l; [ simpl in |- *; tauto | simpl in |- *; intros; apply in_or_app; destruct H; [ left; rewrite H; apply in_prod_aux; assumption | right; auto ] ]. Qed. Lemma in_prod_iff : forall (l:list A)(l':list B)(x:A)(y:B), In (x,y) (list_prod l l') <-> In x l /\ In y l'. Proof. split; [ | intros; apply in_prod; intuition ]. induction l; simpl; intros. intuition. destruct (in_app_or _ _ _ H); clear H. destruct (in_map_iff (fun y : B => (a, y)) l' (x,y)) as (H1,_). destruct (H1 H0) as (z,(H2,H3)); clear H0 H1. injection H2; clear H2; intros; subst; intuition. intuition. Qed. Lemma prod_length : forall (l:list A)(l':list B), length (list_prod l l') = (length l) * (length l'). Proof. induction l; simpl; auto. intros. rewrite app_length. rewrite map_length. auto. Qed. End ListPairs. (***************************************) (** * Miscelenous operations on lists *) (***************************************) (******************************) (** ** Length order of lists *) (******************************) Section length_order. Variable A : Type. Definition lel (l m:list A) := length l <= length m. Variables a b : A. Variables l m n : list A. Lemma lel_refl : lel l l. Proof. unfold lel in |- *; auto with arith. Qed. Lemma lel_trans : lel l m -> lel m n -> lel l n. Proof. unfold lel in |- *; intros. now_show (length l <= length n). apply Nat.le_trans with (length m); auto with arith. Qed. Lemma lel_cons_cons : lel l m -> lel (a :: l) (b :: m). Proof. unfold lel in |- *; simpl in |- *; auto with arith. Qed. Lemma lel_cons : lel l m -> lel l (b :: m). Proof. unfold lel in |- *; simpl in |- *; auto with arith. Qed. Lemma lel_tail : lel (a :: l) (b :: m) -> lel l m. Proof. unfold lel in |- *; simpl in |- *; auto with arith. Qed. Lemma lel_nil : forall l':list A, lel l' nil -> nil = l'. Proof. intro l'; elim l'; auto with arith. intros a' y H H0. now_show (nil = a' :: y). absurd (S (length y) <= 0); auto with arith. Qed. End length_order. #[global] Hint Resolve lel_refl lel_cons_cons lel_cons lel_nil lel_nil nil_cons: datatypes v62. (******************************) (** ** Set inclusion on list *) (******************************) Section SetIncl. Variable A : Type. Definition incl (l m:list A) := forall a:A, In a l -> In a m. Hint Unfold incl : core. Lemma incl_refl : forall l:list A, incl l l. Proof. auto. Qed. Hint Resolve incl_refl : core. Lemma incl_tl : forall (a:A) (l m:list A), incl l m -> incl l (a :: m). Proof. auto with datatypes. Qed. Hint Immediate incl_tl : core. Lemma incl_tran : forall l m n:list A, incl l m -> incl m n -> incl l n. Proof. auto. Qed. Lemma incl_appl : forall l m n:list A, incl l n -> incl l (n ++ m). Proof. auto with datatypes. Qed. Hint Immediate incl_appl : core. Lemma incl_appr : forall l m n:list A, incl l n -> incl l (m ++ n). Proof. auto with datatypes. Qed. Hint Immediate incl_appr : core. Lemma incl_cons : forall (a:A) (l m:list A), In a m -> incl l m -> incl (a :: l) m. Proof. unfold incl in |- *; simpl in |- *; intros a l m H H0 a0 H1. now_show (In a0 m). elim H1. now_show (a = a0 -> In a0 m). elim H1; auto; intro H2. now_show (a = a0 -> In a0 m). elim H2; auto. (* solves subgoal *) now_show (In a0 l -> In a0 m). auto. Qed. Hint Resolve incl_cons : core. Lemma incl_app : forall l m n:list A, incl l n -> incl m n -> incl (l ++ m) n. Proof. unfold incl in |- *; simpl in |- *; intros l m n H H0 a H1. now_show (In a n). elim (in_app_or _ _ _ H1); auto. Qed. Hint Resolve incl_app : core. End SetIncl. #[global] Hint Resolve incl_refl incl_tl incl_tran incl_appl incl_appr incl_cons incl_app: datatypes v62. (**************************************) (** * Cutting a list at some position *) (**************************************) Section Cutting. Variable A : Type. Fixpoint firstn (n:nat)(l:list A) {struct n} : list A := match n with | 0 => nil | S n => match l with | nil => nil | a::l => a::(firstn n l) end end. Fixpoint skipn (n:nat)(l:list A) { struct n } : list A := match n with | 0 => l | S n => match l with | nil => nil | a::l => skipn n l end end. Lemma firstn_skipn : forall n l, firstn n l ++ skipn n l = l. Proof. induction n. simpl; auto. destruct l; simpl; auto. f_equal; auto. Qed. Lemma firstn_length : forall n l, length (firstn n l) = min n (length l). Proof. induction n; destruct l; simpl; auto. Qed. Lemma removelast_firstn : forall n l, n < length l -> removelast (firstn (S n) l) = firstn n l. Proof. induction n; destruct l. simpl; auto. simpl; auto. simpl; auto. intros. simpl in H. change (firstn (S (S n)) (a::l)) with ((a::nil)++firstn (S n) l). change (firstn (S n) (a::l)) with (a::firstn n l). rewrite removelast_app. rewrite IHn; auto with arith. clear IHn; destruct l; simpl in *; try discriminate. inversion_clear H. inversion_clear H0. Qed. Lemma firstn_removelast : forall n l, n < length l -> firstn n (removelast l) = firstn n l. Proof. induction n; destruct l. simpl; auto. simpl; auto. simpl; auto. intros. simpl in H. change (removelast (a :: l)) with (removelast ((a::nil)++l)). rewrite removelast_app. simpl; f_equal; auto with arith. intro H0; rewrite H0 in H; inversion_clear H; inversion_clear H1. Qed. End Cutting. (********************************) (** ** Lists without redundancy *) (********************************) Module ReDun. Parameter A : Type. Inductive NoDup : list A -> Prop := | NoDup_nil : NoDup nil | NoDup_cons : forall x l, ~ In x l -> NoDup l -> NoDup (x::l). Lemma NoDup_remove_1 : forall l l' a, NoDup (l++a::l') -> NoDup (l++l'). Proof. induction l; simpl. inversion_clear 1; auto. inversion_clear 1. constructor. contradict H0. apply in_or_app; destruct (in_app_or _ _ _ H0); simpl; tauto. apply IHl with a0; auto. Qed. Lemma NoDup_remove_2 : forall l l' a, NoDup (l++a::l') -> ~In a (l++l'). Proof. induction l; simpl. inversion_clear 1; auto. inversion_clear 1. contradict H0. destruct H0. subst a0. apply in_or_app; right; red; auto. destruct (IHl _ _ H1); auto. Qed. Lemma NoDup_Permutation : forall l l', NoDup l -> NoDup l' -> (forall x, In x l <-> In x l') -> Permutation l l'. Proof. induction l. destruct l'; simpl; intros. apply perm_nil. destruct (H1 a) as (_,H2); destruct H2; auto. intros. destruct (In_split a l') as (l'1,(l'2,H2)). destruct (H1 a) as (H2,H3); simpl in *; auto. subst l'. apply Permutation_cons_app. inversion_clear H. apply IHl; auto. apply NoDup_remove_1 with a; auto. intro x; split; intros. assert (In x (l'1++a::l'2)). destruct (H1 x); simpl in *; auto. apply in_or_app; destruct (in_app_or _ _ _ H4); auto. destruct H5; auto. subst x; destruct H2; auto. assert (In x (l'1++a::l'2)). apply in_or_app; destruct (in_app_or _ _ _ H); simpl; auto. destruct (H1 x) as (_,H5); destruct H5; auto. subst x. destruct (NoDup_remove_2 _ _ _ H0 H). Qed. End ReDun. (***********************************) (** ** Sequence of natural numbers *) (***********************************) Section NatSeq. (** [seq] computes the sequence of [len] contiguous integers that starts at [start]. For instance, [seq 2 3] is [2::3::4::nil]. *) Fixpoint seq (start len:nat) {struct len} : list nat := match len with | 0 => nil | S len => start :: seq (S start) len end. Lemma seq_length : forall len start, length (seq start len) = len. Proof. induction len; simpl; auto. Qed. Lemma seq_nth : forall len start n d, n < len -> nth n (seq start len) d = start+n. Proof. induction len; intros. inversion H. simpl seq. destruct n; simpl. auto with arith. rewrite IHlen;simpl; auto with arith. Qed. Lemma seq_shift : forall len start, map S (seq start len) = seq (S start) len. Proof. induction len; simpl; auto. intros. rewrite IHlen. auto with arith. Qed. End NatSeq. (** * Exporting hints and tactics *) #[global] Hint Rewrite rev_involutive (* rev (rev l) = l *) rev_unit (* rev (l ++ a :: nil) = a :: rev l *) map_nth (* nth n (map f l) (f d) = f (nth n l d) *) map_length (* length (map f l) = length l *) seq_length (* length (seq start len) = len *) app_length (* length (l ++ l') = length l + length l' *) rev_length (* length (rev l) = length l *) : list. #[global] Hint Rewrite <- app_nil_end (* l = l ++ nil *) : list. Ltac simpl_list := autorewrite with list. Ltac ssimpl_list := autorewrite with list using simpl. coq-dpdgraph-1.0-8.19/tests/attributes.err.dpd000066400000000000000000000012771457702451100211450ustar00rootroot00000000000000N: 1 "one"; /* no attibute */ N: 2 "two" []; /* empty attributes */ N: 3 "three" [ kind=cnst, ] ; /* known attribute with known value */ N: 4 "four" [ kind=unknown, ] ; /* known attribute with unknown value */ N: 5 "five" [ prop=yes, prop=no, ] ; /* known attribute with two values. Should this be an error? */ N: 6 "six" [ another_attribute=42, ]; /* unknown attribute */ E: 1 1; /* no attibute */ E: 1 2 []; /* empty attributes */ E: 1 3 [ weight=1, ] ; /* known attribute with known value */ E: 1 4 [ weight="value", ] ; /* known attribute with unknown value */ /* should not have an error before this one: */ E: 1 10; coq-dpdgraph-1.0-8.19/tests/attributes.err.oracle000066400000000000000000000001331457702451100216310ustar00rootroot00000000000000Info: read file tests/attributes.err.dpd Error: no node with number 10: cannot build edge. coq-dpdgraph-1.0-8.19/tests/double_node.err.dpd000066400000000000000000000000721457702451100212260ustar00rootroot00000000000000N: 1 "one"; N: 2 "two"; N: 4 "four"; N: 2 "another two"; coq-dpdgraph-1.0-8.19/tests/double_node.err.oracle000066400000000000000000000002371457702451100217270ustar00rootroot00000000000000Info: read file tests/double_node.err.dpd Error: a node named 'two' already has the number 2. Cannot create new node named 'another two' with the same number. coq-dpdgraph-1.0-8.19/tests/file_not_found.err.oracle000066400000000000000000000001411457702451100224340ustar00rootroot00000000000000Info: read file file_not_found.err.dpd Error: file_not_found.err.dpd: No such file or directory. coq-dpdgraph-1.0-8.19/tests/graph.dot.oracle000066400000000000000000001132161457702451100205510ustar00rootroot00000000000000digraph tests/graph { graph [ratio=0.5] node [style=filled] Test_removelast_app [label="removelast_app", URL=, fillcolor="#7FFFD4"] ; Test_exists_last [label="exists_last", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_ReDun_NoDup_Permutation [label="NoDup_Permutation", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_removelast_last [label="app_removelast_last", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_remove_2 [label="NoDup_remove_2", URL=, fillcolor="#7FFFD4"] ; Test_removelast [label="removelast", URL=, fillcolor="#F070D1"] ; Test_ReDun_NoDup_remove_1 [label="NoDup_remove_1", URL=, fillcolor="#7FFFD4"] ; Test_last [label="last", URL=, fillcolor="#F070D1"] ; Test_ReDun_NoDup_sind [label="NoDup_sind", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_remove_In [label="remove_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_ind [label="NoDup_ind", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_cons [label="NoDup_cons", URL=, fillcolor="#7FAAFF"] ; Test_remove [label="remove", URL=, fillcolor="#F070D1"] ; Test_ReDun_NoDup_nil [label="NoDup_nil", URL=, peripheries=3, fillcolor="#7FAAFF"] ; Test_app_nth2 [label="app_nth2", URL=, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup [label="NoDup", URL=, fillcolor="#E2CDFA"] ; Test_app_nth1 [label="app_nth1", URL=, fillcolor="#7FFFD4"] ; Test_nth_indep [label="nth_indep", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_A [label="A", URL=, fillcolor="#FACDEF"] ; Test_seq_shift [label="seq_shift", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_overflow [label="nth_overflow", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_seq_nth [label="seq_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_In [label="nth_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_seq_length [label="seq_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_default [label="nth_default", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_seq [label="seq", URL=, fillcolor="#F070D1"] ; Test_nth_error [label="nth_error", URL=, fillcolor="#F070D1"] ; Test_nth_S_cons [label="nth_S_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_firstn_removelast [label="firstn_removelast", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_removelast_firstn [label="removelast_firstn", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_in_or_default [label="nth_in_or_default", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_nth_ok [label="nth_ok", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_firstn_length [label="firstn_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth [label="nth", URL=, fillcolor="#F070D1"] ; Test_firstn_skipn [label="firstn_skipn", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_skipn [label="skipn", URL=, fillcolor="#F070D1"] ; Test_app_inv_tail [label="app_inv_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_firstn [label="firstn", URL=, fillcolor="#F070D1"] ; Test_app_inv_head [label="app_inv_head", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_app [label="incl_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_or_app [label="in_or_app", URL=, fillcolor="#7FFFD4"] ; Test_incl_cons [label="incl_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_app_or [label="in_app_or", URL=, fillcolor="#7FFFD4"] ; Test_incl_appr [label="incl_appr", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_length [label="app_length", URL=, fillcolor="#7FFFD4"] ; Test_incl_appl [label="incl_appl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_inj_tail [label="app_inj_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_tran [label="incl_tran", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_eq_unit [label="app_eq_unit", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_tl [label="incl_tl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_eq_nil [label="app_eq_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_refl [label="incl_refl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_comm_cons [label="app_comm_cons", URL=, fillcolor="#7FFFD4"] ; Test_incl [label="incl", URL=, fillcolor="#F070D1"] ; Test_ass_app [label="ass_app", URL=, fillcolor="#7FFFD4"] ; Test_lel_nil [label="lel_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_ass [label="app_ass", URL=, fillcolor="#7FFFD4"] ; Test_lel_tail [label="lel_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_nil_end [label="app_nil_end", URL=, fillcolor="#7FFFD4"] ; Test_lel_cons [label="lel_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_cons_not_nil [label="app_cons_not_nil", URL=, fillcolor="#7FFFD4"] ; Test_lel_cons_cons [label="lel_cons_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_In_dec [label="In_dec", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_lel_trans [label="lel_trans", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_inv [label="in_inv", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_lel_refl [label="lel_refl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_In_split [label="In_split", URL=, fillcolor="#7FFFD4"] ; Test_lel [label="lel", URL=, fillcolor="#F070D1"] ; Test_in_nil [label="in_nil", URL=, fillcolor="#7FFFD4"] ; Test_prod_length [label="prod_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_cons [label="in_cons", URL=, fillcolor="#7FFFD4"] ; Test_in_prod_iff [label="in_prod_iff", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_eq [label="in_eq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_prod [label="in_prod", URL=, fillcolor="#7FFFD4"] ; Test_head_cons [label="head_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_prod_aux [label="in_prod_aux", URL=, fillcolor="#7FFFD4"] ; Test_head_nil [label="head_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_list_prod [label="list_prod", URL=, fillcolor="#F070D1"] ; Test_destruct_list [label="destruct_list", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_nil_cons [label="nil_cons", URL=, fillcolor="#7FFFD4"] ; Test_combine_nth [label="combine_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_combine_length [label="combine_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app [label="app", URL=, fillcolor="#F070D1"] ; Test_in_combine_r [label="in_combine_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_In [label="In", URL=, fillcolor="#F070D1"] ; Test_size_nil [label="size_nil", URL=, peripheries=3, fillcolor="#FFB57F"] ; Test_in_combine_l [label="in_combine_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_size [label="size", URL=, fillcolor="#FACDEF"] ; Test_combine_split [label="combine_split", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split_combine [label="split_combine", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_length [label="length", URL=, fillcolor="#F070D1"] ; Test_tail [label="tail", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_combine [label="combine", URL=, fillcolor="#F070D1"] ; Test_split_length_r [label="split_length_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_hd [label="hd", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_split_length_l [label="split_length_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_head [label="head", URL=, fillcolor="#F070D1"] ; Test_split_nth [label="split_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_list_sind [label="list_sind", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_list_rec [label="list_rec", URL=, fillcolor="#F070D1"] ; Test_in_split_r [label="in_split_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_list_ind [label="list_ind", URL=, fillcolor="#7FFFD4"] ; Test_in_split_l [label="in_split_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split [label="split", URL=, fillcolor="#F070D1"] ; Test_list_rect [label="list_rect", URL=, fillcolor="#F070D1"] ; Test_cons [label="cons", URL=, fillcolor="#7FAAFF"] ; Test_partition [label="partition", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_nil [label="nil", URL=, fillcolor="#7FAAFF"] ; Test_find [label="find", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_list [label="list", URL=, fillcolor="#E2CDFA"] ; Test_filter_In [label="filter_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_filter [label="filter", URL=, fillcolor="#F070D1"] ; Test_forallb_forall [label="forallb_forall", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_forallb [label="forallb", URL=, fillcolor="#F070D1"] ; Test_existsb_nth [label="existsb_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_existsb_exists [label="existsb_exists", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_existsb [label="existsb", URL=, fillcolor="#F070D1"] ; Test_list_power [label="list_power", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_fold_symmetric [label="fold_symmetric", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_left_rev_right [label="fold_left_rev_right", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_right_app [label="fold_right_app", URL=, fillcolor="#7FFFD4"] ; Test_fold_right [label="fold_right", URL=, fillcolor="#F070D1"] ; Test_fold_left_length [label="fold_left_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_left_app [label="fold_left_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_left [label="fold_left", URL=, fillcolor="#F070D1"] ; Test_map_ext [label="map_ext", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_map [label="map_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_flat_map [label="in_flat_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_flat_map [label="flat_map", URL=, fillcolor="#F070D1"] ; Test_Permutation_map [label="Permutation_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_rev [label="map_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_app [label="map_app", URL=, fillcolor="#7FFFD4"] ; Test_map_nth [label="map_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_length [label="map_length", URL=, fillcolor="#7FFFD4"] ; Test_in_map_iff [label="in_map_iff", URL=, fillcolor="#7FFFD4"] ; Test_in_map [label="in_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map [label="map", URL=, fillcolor="#F070D1"] ; Test_list_eq_dec [label="list_eq_dec", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_Permutation_app_inv_r [label="Permutation_app_inv_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_app_inv_l [label="Permutation_app_inv_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_app_inv [label="Permutation_cons_app_inv", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_inv [label="Permutation_cons_inv", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_inv [label="Permutation_app_inv", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_ind_bis [label="Permutation_ind_bis", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_rev [label="Permutation_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_length [label="Permutation_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_app [label="Permutation_cons_app", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_swap [label="Permutation_app_swap", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app [label="Permutation_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_app_head [label="Permutation_app_head", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_tail [label="Permutation_app_tail", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_in [label="Permutation_in", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_trans [label="Permutation_trans", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_sym [label="Permutation_sym", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_refl [label="Permutation_refl", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_nil_cons [label="Permutation_nil_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_nil [label="Permutation_nil", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_sind [label="Permutation_sind", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_Permutation_ind [label="Permutation_ind", URL=, fillcolor="#7FFFD4"] ; Test_perm_trans [label="perm_trans", URL=, fillcolor="#7FAAFF"] ; Test_perm_swap [label="perm_swap", URL=, fillcolor="#7FAAFF"] ; Test_perm_skip [label="perm_skip", URL=, fillcolor="#7FAAFF"] ; Test_perm_nil [label="perm_nil", URL=, fillcolor="#7FAAFF"] ; Test_Permutation [label="Permutation", URL=, fillcolor="#E2CDFA"] ; Test_rev_ind [label="rev_ind", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_list_ind [label="rev_list_ind", URL=, fillcolor="#7FFFD4"] ; Test_rev_alt [label="rev_alt", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_append_rev [label="rev_append_rev", URL=, fillcolor="#7FFFD4"] ; Test_rev_ [label="rev'", URL=, peripheries=3, fillcolor="#F070D1"] ; Test_rev_append [label="rev_append", URL=, fillcolor="#F070D1"] ; Test_rev_nth [label="rev_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_length [label="rev_length", URL=, fillcolor="#7FFFD4"] ; Test_In_rev [label="In_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_involutive [label="rev_involutive", URL=, fillcolor="#7FFFD4"] ; Test_rev_unit [label="rev_unit", URL=, fillcolor="#7FFFD4"] ; Test_distr_rev [label="distr_rev", URL=, fillcolor="#7FFFD4"] ; Test_rev [label="rev", URL=, fillcolor="#F070D1"] ; Test_count_occ_cons_neq [label="count_occ_cons_neq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_cons_eq [label="count_occ_cons_eq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_nil [label="count_occ_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_inv_nil [label="count_occ_inv_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_In [label="count_occ_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ [label="count_occ", URL=, fillcolor="#F070D1"] ; Test_removelast_app -> Test_removelast [] ; Test_removelast_app -> Test_app [] ; Test_removelast_app -> Test_list_ind [] ; Test_exists_last -> Test_app [] ; Test_exists_last -> Test_list_rect [] ; Test_ReDun_NoDup_Permutation -> Test_ReDun_NoDup_remove_2 [] ; Test_ReDun_NoDup_Permutation -> Test_ReDun_NoDup_remove_1 [] ; Test_ReDun_NoDup_Permutation -> Test_Permutation_cons_app [] ; Test_ReDun_NoDup_Permutation -> Test_In_split [] ; Test_app_removelast_last -> Test_removelast [] ; Test_app_removelast_last -> Test_last [] ; Test_app_removelast_last -> Test_app [] ; Test_app_removelast_last -> Test_list_ind [] ; Test_ReDun_NoDup_remove_2 -> Test_ReDun_NoDup [] ; Test_ReDun_NoDup_remove_2 -> Test_in_or_app [] ; Test_removelast -> Test_cons [] ; Test_removelast -> Test_nil [] ; Test_removelast -> Test_list [] ; Test_ReDun_NoDup_remove_1 -> Test_ReDun_NoDup_cons [] ; Test_ReDun_NoDup_remove_1 -> Test_ReDun_NoDup [] ; Test_ReDun_NoDup_remove_1 -> Test_in_or_app [] ; Test_ReDun_NoDup_remove_1 -> Test_in_app_or [] ; Test_last -> Test_list [] ; Test_ReDun_NoDup_sind -> Test_ReDun_NoDup [] ; Test_remove_In -> Test_remove [] ; Test_remove_In -> Test_In [] ; Test_remove_In -> Test_list_ind [] ; Test_ReDun_NoDup_ind -> Test_ReDun_NoDup [] ; Test_ReDun_NoDup_cons -> Test_ReDun_A [] ; Test_ReDun_NoDup_cons -> Test_In [] ; Test_ReDun_NoDup_cons -> Test_cons [] ; Test_ReDun_NoDup_cons -> Test_nil [] ; Test_remove -> Test_cons [] ; Test_remove -> Test_nil [] ; Test_remove -> Test_list [] ; Test_ReDun_NoDup_nil -> Test_ReDun_A [] ; Test_ReDun_NoDup_nil -> Test_In [] ; Test_ReDun_NoDup_nil -> Test_cons [] ; Test_ReDun_NoDup_nil -> Test_nil [] ; Test_app_nth2 -> Test_nth [] ; Test_app_nth2 -> Test_app [] ; Test_app_nth2 -> Test_length [] ; Test_app_nth2 -> Test_list_ind [] ; Test_ReDun_NoDup -> Test_ReDun_A [] ; Test_ReDun_NoDup -> Test_In [] ; Test_ReDun_NoDup -> Test_cons [] ; Test_ReDun_NoDup -> Test_nil [] ; Test_app_nth1 -> Test_nth [] ; Test_app_nth1 -> Test_app [] ; Test_app_nth1 -> Test_length [] ; Test_app_nth1 -> Test_list_ind [] ; Test_nth_indep -> Test_nth [] ; Test_nth_indep -> Test_length [] ; Test_nth_indep -> Test_list_ind [] ; Test_seq_shift -> Test_seq [] ; Test_seq_shift -> Test_map [] ; Test_nth_overflow -> Test_nth [] ; Test_nth_overflow -> Test_length [] ; Test_nth_overflow -> Test_list_ind [] ; Test_seq_nth -> Test_seq [] ; Test_seq_nth -> Test_nth [] ; Test_nth_In -> Test_nth [] ; Test_nth_In -> Test_In [] ; Test_nth_In -> Test_length [] ; Test_nth_In -> Test_cons [] ; Test_nth_In -> Test_nil [] ; Test_seq_length -> Test_seq [] ; Test_seq_length -> Test_length [] ; Test_nth_default -> Test_nth_error [] ; Test_seq -> Test_cons [] ; Test_seq -> Test_nil [] ; Test_seq -> Test_list [] ; Test_nth_error -> Test_list [] ; Test_nth_S_cons -> Test_nth [] ; Test_nth_S_cons -> Test_In [] ; Test_nth_S_cons -> Test_cons [] ; Test_firstn_removelast -> Test_firstn [] ; Test_firstn_removelast -> Test_removelast_app [] ; Test_firstn_removelast -> Test_length [] ; Test_removelast_firstn -> Test_firstn [] ; Test_removelast_firstn -> Test_removelast_app [] ; Test_removelast_firstn -> Test_length [] ; Test_nth_in_or_default -> Test_nth [] ; Test_nth_in_or_default -> Test_In [] ; Test_nth_in_or_default -> Test_list_rec [] ; Test_nth_ok -> Test_list [] ; Test_firstn_length -> Test_firstn [] ; Test_firstn_length -> Test_length [] ; Test_nth -> Test_list [] ; Test_firstn_skipn -> Test_skipn [] ; Test_firstn_skipn -> Test_firstn [] ; Test_firstn_skipn -> Test_app [] ; Test_skipn -> Test_nil [] ; Test_skipn -> Test_list [] ; Test_app_inv_tail -> Test_app_length [] ; Test_firstn -> Test_cons [] ; Test_firstn -> Test_nil [] ; Test_firstn -> Test_list [] ; Test_app_inv_head -> Test_app [] ; Test_app_inv_head -> Test_list_ind [] ; Test_incl_app -> Test_incl [] ; Test_incl_app -> Test_in_app_or [] ; Test_in_or_app -> Test_app [] ; Test_in_or_app -> Test_In [] ; Test_in_or_app -> Test_list_ind [] ; Test_incl_cons -> Test_incl [] ; Test_incl_cons -> Test_cons [] ; Test_in_app_or -> Test_app [] ; Test_in_app_or -> Test_In [] ; Test_in_app_or -> Test_list_ind [] ; Test_incl_appr -> Test_incl [] ; Test_incl_appr -> Test_in_or_app [] ; Test_app_length -> Test_app [] ; Test_app_length -> Test_length [] ; Test_app_length -> Test_list_ind [] ; Test_incl_appl -> Test_incl [] ; Test_incl_appl -> Test_in_or_app [] ; Test_app_inj_tail -> Test_app_cons_not_nil [] ; Test_app_inj_tail -> Test_list_ind [] ; Test_incl_tran -> Test_incl [] ; Test_app_eq_unit -> Test_app_nil_end [] ; Test_app_eq_unit -> Test_app_cons_not_nil [] ; Test_incl_tl -> Test_incl [] ; Test_incl_tl -> Test_in_cons [] ; Test_app_eq_nil -> Test_app [] ; Test_app_eq_nil -> Test_nil [] ; Test_incl_refl -> Test_incl [] ; Test_app_comm_cons -> Test_app [] ; Test_incl -> Test_In [] ; Test_ass_app -> Test_app_ass [] ; Test_lel_nil -> Test_lel [] ; Test_lel_nil -> Test_list_ind [] ; Test_app_ass -> Test_app [] ; Test_app_ass -> Test_list_ind [] ; Test_lel_tail -> Test_lel [] ; Test_lel_tail -> Test_cons [] ; Test_app_nil_end -> Test_app [] ; Test_app_nil_end -> Test_list_ind [] ; Test_lel_cons -> Test_lel [] ; Test_lel_cons -> Test_cons [] ; Test_app_cons_not_nil -> Test_app [] ; Test_app_cons_not_nil -> Test_nil [] ; Test_lel_cons_cons -> Test_lel [] ; Test_lel_cons_cons -> Test_cons [] ; Test_In_dec -> Test_in_nil [] ; Test_In_dec -> Test_list_rec [] ; Test_lel_trans -> Test_lel [] ; Test_in_inv -> Test_In [] ; Test_in_inv -> Test_cons [] ; Test_lel_refl -> Test_lel [] ; Test_In_split -> Test_app [] ; Test_In_split -> Test_In [] ; Test_In_split -> Test_list_ind [] ; Test_lel -> Test_length [] ; Test_in_nil -> Test_In [] ; Test_in_nil -> Test_nil [] ; Test_prod_length -> Test_list_prod [] ; Test_prod_length -> Test_map_length [] ; Test_prod_length -> Test_app_length [] ; Test_in_cons -> Test_In [] ; Test_in_cons -> Test_cons [] ; Test_in_prod_iff -> Test_in_prod [] ; Test_in_prod_iff -> Test_in_map_iff [] ; Test_in_prod_iff -> Test_in_app_or [] ; Test_in_eq -> Test_In [] ; Test_in_eq -> Test_cons [] ; Test_in_prod -> Test_in_prod_aux [] ; Test_in_prod -> Test_list_prod [] ; Test_in_prod -> Test_in_or_app [] ; Test_head_cons -> Test_head [] ; Test_head_cons -> Test_cons [] ; Test_in_prod_aux -> Test_map [] ; Test_in_prod_aux -> Test_In [] ; Test_in_prod_aux -> Test_list_ind [] ; Test_head_nil -> Test_head [] ; Test_head_nil -> Test_nil [] ; Test_list_prod -> Test_map [] ; Test_list_prod -> Test_app [] ; Test_destruct_list -> Test_list_rect [] ; Test_nil_cons -> Test_cons [] ; Test_nil_cons -> Test_nil [] ; Test_nil_cons -> Test_list [] ; Test_combine_nth -> Test_combine [] ; Test_combine_nth -> Test_nth [] ; Test_combine_nth -> Test_length [] ; Test_combine_nth -> Test_list_ind [] ; Test_combine_length -> Test_combine [] ; Test_combine_length -> Test_length [] ; Test_combine_length -> Test_list_ind [] ; Test_app -> Test_cons [] ; Test_app -> Test_list [] ; Test_in_combine_r -> Test_combine [] ; Test_in_combine_r -> Test_In [] ; Test_in_combine_r -> Test_list_ind [] ; Test_In -> Test_list [] ; Test_size_nil -> Test_size [] ; Test_size_nil -> Test_nil [] ; Test_in_combine_l -> Test_combine [] ; Test_in_combine_l -> Test_In [] ; Test_in_combine_l -> Test_list_ind [] ; Test_size -> Test_list [] ; Test_combine_split -> Test_combine [] ; Test_combine_split -> Test_split [] ; Test_combine_split -> Test_length [] ; Test_combine_split -> Test_list_ind [] ; Test_split_combine -> Test_combine [] ; Test_split_combine -> Test_split [] ; Test_split_combine -> Test_list_ind [] ; Test_length -> Test_list [] ; Test_tail -> Test_nil [] ; Test_tail -> Test_list [] ; Test_combine -> Test_cons [] ; Test_combine -> Test_nil [] ; Test_combine -> Test_list [] ; Test_split_length_r -> Test_split [] ; Test_split_length_r -> Test_length [] ; Test_split_length_r -> Test_list_ind [] ; Test_hd -> Test_list [] ; Test_split_length_l -> Test_split [] ; Test_split_length_l -> Test_length [] ; Test_split_length_l -> Test_list_ind [] ; Test_head -> Test_list [] ; Test_split_nth -> Test_split [] ; Test_split_nth -> Test_nth [] ; Test_split_nth -> Test_list_ind [] ; Test_list_sind -> Test_cons [] ; Test_list_sind -> Test_nil [] ; Test_list_sind -> Test_list [] ; Test_list_rec -> Test_list_rect [] ; Test_in_split_r -> Test_split [] ; Test_in_split_r -> Test_In [] ; Test_in_split_r -> Test_list_ind [] ; Test_list_ind -> Test_cons [] ; Test_list_ind -> Test_nil [] ; Test_list_ind -> Test_list [] ; Test_in_split_l -> Test_split [] ; Test_in_split_l -> Test_In [] ; Test_in_split_l -> Test_list_ind [] ; Test_split -> Test_cons [] ; Test_split -> Test_nil [] ; Test_split -> Test_list [] ; Test_list_rect -> Test_cons [] ; Test_list_rect -> Test_nil [] ; Test_list_rect -> Test_list [] ; Test_partition -> Test_cons [] ; Test_partition -> Test_nil [] ; Test_partition -> Test_list [] ; Test_find -> Test_list [] ; Test_filter_In -> Test_filter [] ; Test_filter_In -> Test_In [] ; Test_filter_In -> Test_list_ind [] ; Test_filter -> Test_cons [] ; Test_filter -> Test_nil [] ; Test_filter -> Test_list [] ; Test_forallb_forall -> Test_forallb [] ; Test_forallb_forall -> Test_In [] ; Test_forallb_forall -> Test_list_ind [] ; Test_forallb -> Test_list [] ; Test_existsb_nth -> Test_existsb [] ; Test_existsb_nth -> Test_nth [] ; Test_existsb_nth -> Test_length [] ; Test_existsb_nth -> Test_list_ind [] ; Test_existsb_exists -> Test_existsb [] ; Test_existsb_exists -> Test_In [] ; Test_existsb_exists -> Test_list_ind [] ; Test_existsb -> Test_list [] ; Test_list_power -> Test_flat_map [] ; Test_list_power -> Test_map [] ; Test_fold_symmetric -> Test_fold_right [] ; Test_fold_symmetric -> Test_fold_left [] ; Test_fold_symmetric -> Test_list_ind [] ; Test_fold_left_rev_right -> Test_fold_right_app [] ; Test_fold_left_rev_right -> Test_fold_left [] ; Test_fold_left_rev_right -> Test_rev [] ; Test_fold_right_app -> Test_fold_right [] ; Test_fold_right_app -> Test_app [] ; Test_fold_right_app -> Test_list_ind [] ; Test_fold_right -> Test_list [] ; Test_fold_left_length -> Test_fold_left [] ; Test_fold_left_length -> Test_length [] ; Test_fold_left_length -> Test_list_ind [] ; Test_fold_left_app -> Test_fold_left [] ; Test_fold_left_app -> Test_app [] ; Test_fold_left_app -> Test_list_ind [] ; Test_fold_left -> Test_list [] ; Test_map_ext -> Test_map [] ; Test_map_ext -> Test_list_ind [] ; Test_map_map -> Test_map [] ; Test_map_map -> Test_list_ind [] ; Test_in_flat_map -> Test_flat_map [] ; Test_in_flat_map -> Test_in_or_app [] ; Test_in_flat_map -> Test_in_app_or [] ; Test_flat_map -> Test_app [] ; Test_flat_map -> Test_nil [] ; Test_Permutation_map -> Test_map [] ; Test_Permutation_map -> Test_Permutation_ind [] ; Test_Permutation_map -> Test_perm_trans [] ; Test_Permutation_map -> Test_perm_swap [] ; Test_Permutation_map -> Test_perm_skip [] ; Test_Permutation_map -> Test_perm_nil [] ; Test_map_rev -> Test_map_app [] ; Test_map_rev -> Test_rev [] ; Test_map_app -> Test_map [] ; Test_map_app -> Test_app [] ; Test_map_app -> Test_list_ind [] ; Test_map_nth -> Test_map [] ; Test_map_nth -> Test_nth [] ; Test_map_nth -> Test_list_ind [] ; Test_map_length -> Test_map [] ; Test_map_length -> Test_length [] ; Test_map_length -> Test_list_ind [] ; Test_in_map_iff -> Test_map [] ; Test_in_map_iff -> Test_In [] ; Test_in_map_iff -> Test_list_ind [] ; Test_in_map -> Test_map [] ; Test_in_map -> Test_In [] ; Test_in_map -> Test_list_ind [] ; Test_map -> Test_cons [] ; Test_map -> Test_nil [] ; Test_map -> Test_list [] ; Test_list_eq_dec -> Test_nil_cons [] ; Test_list_eq_dec -> Test_list_rect [] ; Test_Permutation_app_inv_r -> Test_Permutation_app_inv [] ; Test_Permutation_app_inv_r -> Test_app_nil_end [] ; Test_Permutation_app_inv_l -> Test_Permutation_cons_inv [] ; Test_Permutation_cons_app_inv -> Test_Permutation_app_inv [] ; Test_Permutation_cons_inv -> Test_Permutation_app_inv [] ; Test_Permutation_app_inv -> Test_Permutation_ind_bis [] ; Test_Permutation_app_inv -> Test_Permutation_cons_app [] ; Test_Permutation_app_inv -> Test_Permutation_in [] ; Test_Permutation_app_inv -> Test_Permutation_sym [] ; Test_Permutation_app_inv -> Test_in_or_app [] ; Test_Permutation_app_inv -> Test_In_split [] ; Test_Permutation_ind_bis -> Test_Permutation_refl [] ; Test_Permutation_ind_bis -> Test_Permutation_ind [] ; Test_Permutation_ind_bis -> Test_perm_swap [] ; Test_Permutation_rev -> Test_Permutation_app_swap [] ; Test_Permutation_rev -> Test_rev [] ; Test_Permutation_length -> Test_Permutation_ind [] ; Test_Permutation_length -> Test_length [] ; Test_Permutation_cons_app -> Test_Permutation_refl [] ; Test_Permutation_cons_app -> Test_perm_trans [] ; Test_Permutation_cons_app -> Test_perm_swap [] ; Test_Permutation_cons_app -> Test_app [] ; Test_Permutation_app_swap -> Test_Permutation_trans [] ; Test_Permutation_app_swap -> Test_Permutation_sym [] ; Test_Permutation_app_swap -> Test_Permutation_refl [] ; Test_Permutation_app_swap -> Test_app_comm_cons [] ; Test_Permutation_app_swap -> Test_app_nil_end [] ; Test_Permutation_app -> Test_Permutation_app_head [] ; Test_Permutation_app -> Test_Permutation_app_tail [] ; Test_Permutation_app_head -> Test_perm_skip [] ; Test_Permutation_app_head -> Test_Permutation [] ; Test_Permutation_app_head -> Test_app_comm_cons [] ; Test_Permutation_app_head -> Test_list_ind [] ; Test_Permutation_app_tail -> Test_Permutation_trans [] ; Test_Permutation_app_tail -> Test_Permutation_sym [] ; Test_Permutation_app_tail -> Test_Permutation_refl [] ; Test_Permutation_app_tail -> Test_app [] ; Test_Permutation_in -> Test_Permutation_ind [] ; Test_Permutation_in -> Test_In [] ; Test_Permutation_trans -> Test_perm_trans [] ; Test_Permutation_trans -> Test_Permutation [] ; Test_Permutation_sym -> Test_Permutation_ind [] ; Test_Permutation_sym -> Test_perm_trans [] ; Test_Permutation_sym -> Test_perm_swap [] ; Test_Permutation_sym -> Test_perm_skip [] ; Test_Permutation_sym -> Test_perm_nil [] ; Test_Permutation_refl -> Test_perm_skip [] ; Test_Permutation_refl -> Test_perm_nil [] ; Test_Permutation_refl -> Test_Permutation [] ; Test_Permutation_refl -> Test_list_ind [] ; Test_Permutation_nil_cons -> Test_Permutation_nil [] ; Test_Permutation_nil -> Test_Permutation_ind [] ; Test_Permutation_nil -> Test_nil_cons [] ; Test_Permutation_sind -> Test_Permutation [] ; Test_Permutation_ind -> Test_Permutation [] ; Test_perm_trans -> Test_cons [] ; Test_perm_trans -> Test_nil [] ; Test_perm_trans -> Test_list [] ; Test_perm_swap -> Test_cons [] ; Test_perm_swap -> Test_nil [] ; Test_perm_swap -> Test_list [] ; Test_perm_skip -> Test_cons [] ; Test_perm_skip -> Test_nil [] ; Test_perm_skip -> Test_list [] ; Test_perm_nil -> Test_cons [] ; Test_perm_nil -> Test_nil [] ; Test_perm_nil -> Test_list [] ; Test_Permutation -> Test_cons [] ; Test_Permutation -> Test_nil [] ; Test_Permutation -> Test_list [] ; Test_rev_ind -> Test_rev_list_ind [] ; Test_rev_ind -> Test_rev_involutive [] ; Test_rev_list_ind -> Test_rev [] ; Test_rev_list_ind -> Test_list_ind [] ; Test_rev_alt -> Test_rev_append_rev [] ; Test_rev_alt -> Test_app_nil_end [] ; Test_rev_append_rev -> Test_rev_append [] ; Test_rev_append_rev -> Test_rev [] ; Test_rev_append_rev -> Test_ass_app [] ; Test_rev_ -> Test_rev_append [] ; Test_rev_ -> Test_nil [] ; Test_rev_append -> Test_cons [] ; Test_rev_append -> Test_list [] ; Test_rev_nth -> Test_rev_length [] ; Test_rev_nth -> Test_app_nth2 [] ; Test_rev_nth -> Test_app_nth1 [] ; Test_rev_length -> Test_rev [] ; Test_rev_length -> Test_app_length [] ; Test_In_rev -> Test_rev [] ; Test_In_rev -> Test_in_or_app [] ; Test_In_rev -> Test_in_app_or [] ; Test_rev_involutive -> Test_rev_unit [] ; Test_rev_unit -> Test_distr_rev [] ; Test_distr_rev -> Test_rev [] ; Test_distr_rev -> Test_app_ass [] ; Test_distr_rev -> Test_app_nil_end [] ; Test_rev -> Test_app [] ; Test_rev -> Test_nil [] ; Test_count_occ_cons_neq -> Test_count_occ [] ; Test_count_occ_cons_neq -> Test_cons [] ; Test_count_occ_cons_eq -> Test_count_occ [] ; Test_count_occ_cons_eq -> Test_cons [] ; Test_count_occ_nil -> Test_count_occ [] ; Test_count_occ_nil -> Test_nil [] ; Test_count_occ_inv_nil -> Test_count_occ [] ; Test_count_occ_inv_nil -> Test_list_ind [] ; Test_count_occ_In -> Test_count_occ [] ; Test_count_occ_In -> Test_In [] ; Test_count_occ_In -> Test_list_ind [] ; Test_count_occ -> Test_list [] ; subgraph cluster_Test { label="Test"; fillcolor="#FFFFC3"; labeljust=l; style=filled subgraph cluster_Test_ReDun { label="ReDun"; fillcolor="#FFFFA3"; labeljust=l; style=filled Test_ReDun_A; Test_ReDun_NoDup; Test_ReDun_NoDup_nil; Test_ReDun_NoDup_cons; Test_ReDun_NoDup_ind; Test_ReDun_NoDup_sind; Test_ReDun_NoDup_remove_1; Test_ReDun_NoDup_remove_2; Test_ReDun_NoDup_Permutation; }; Test_count_occ; Test_count_occ_In; Test_count_occ_inv_nil; Test_count_occ_nil; Test_count_occ_cons_eq; Test_count_occ_cons_neq; Test_rev; Test_distr_rev; Test_rev_unit; Test_rev_involutive; Test_In_rev; Test_rev_length; Test_rev_nth; Test_rev_append; Test_rev_; Test_rev_append_rev; Test_rev_alt; Test_rev_list_ind; Test_rev_ind; Test_Permutation; Test_perm_nil; Test_perm_skip; Test_perm_swap; Test_perm_trans; Test_Permutation_ind; Test_Permutation_sind; Test_Permutation_nil; Test_Permutation_nil_cons; Test_Permutation_refl; Test_Permutation_sym; Test_Permutation_trans; Test_Permutation_in; Test_Permutation_app_tail; Test_Permutation_app_head; Test_Permutation_app; Test_Permutation_app_swap; Test_Permutation_cons_app; Test_Permutation_length; Test_Permutation_rev; Test_Permutation_ind_bis; Test_Permutation_app_inv; Test_Permutation_cons_inv; Test_Permutation_cons_app_inv; Test_Permutation_app_inv_l; Test_Permutation_app_inv_r; Test_list_eq_dec; Test_map; Test_in_map; Test_in_map_iff; Test_map_length; Test_map_nth; Test_map_app; Test_map_rev; Test_Permutation_map; Test_flat_map; Test_in_flat_map; Test_map_map; Test_map_ext; Test_fold_left; Test_fold_left_app; Test_fold_left_length; Test_fold_right; Test_fold_right_app; Test_fold_left_rev_right; Test_fold_symmetric; Test_list_power; Test_existsb; Test_existsb_exists; Test_existsb_nth; Test_forallb; Test_forallb_forall; Test_filter; Test_filter_In; Test_list; Test_find; Test_nil; Test_partition; Test_cons; Test_list_rect; Test_split; Test_in_split_l; Test_list_ind; Test_in_split_r; Test_list_rec; Test_list_sind; Test_split_nth; Test_head; Test_split_length_l; Test_hd; Test_split_length_r; Test_combine; Test_tail; Test_length; Test_split_combine; Test_combine_split; Test_size; Test_in_combine_l; Test_size_nil; Test_In; Test_in_combine_r; Test_app; Test_combine_length; Test_combine_nth; Test_nil_cons; Test_destruct_list; Test_list_prod; Test_head_nil; Test_in_prod_aux; Test_head_cons; Test_in_prod; Test_in_eq; Test_in_prod_iff; Test_in_cons; Test_prod_length; Test_in_nil; Test_lel; Test_In_split; Test_lel_refl; Test_in_inv; Test_lel_trans; Test_In_dec; Test_lel_cons_cons; Test_app_cons_not_nil; Test_lel_cons; Test_app_nil_end; Test_lel_tail; Test_app_ass; Test_lel_nil; Test_ass_app; Test_incl; Test_app_comm_cons; Test_incl_refl; Test_app_eq_nil; Test_incl_tl; Test_app_eq_unit; Test_incl_tran; Test_app_inj_tail; Test_incl_appl; Test_app_length; Test_incl_appr; Test_in_app_or; Test_incl_cons; Test_in_or_app; Test_incl_app; Test_app_inv_head; Test_firstn; Test_app_inv_tail; Test_skipn; Test_firstn_skipn; Test_nth; Test_firstn_length; Test_nth_ok; Test_nth_in_or_default; Test_removelast_firstn; Test_firstn_removelast; Test_nth_S_cons; Test_nth_error; Test_seq; Test_nth_default; Test_seq_length; Test_nth_In; Test_seq_nth; Test_nth_overflow; Test_seq_shift; Test_nth_indep; Test_app_nth1; Test_app_nth2; Test_remove; Test_remove_In; Test_last; Test_removelast; Test_app_removelast_last; Test_exists_last; Test_removelast_app; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/graph.dpd.oracle000066400000000000000000001037701457702451100205360ustar00rootroot00000000000000N: 9 "A" [body=no, kind=cnst, prop=no, path="Test.ReDun", ]; N: 170 "In" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 159 "In_dec" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 117 "In_rev" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 161 "In_split" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 1 "NoDup_Permutation" [body=yes, kind=cnst, prop=yes, path="Test.ReDun", ]; N: 5 "NoDup_ind" [body=yes, kind=cnst, prop=yes, path="Test.ReDun", ]; N: 3 "NoDup_remove_1" [body=yes, kind=cnst, prop=yes, path="Test.ReDun", ]; N: 2 "NoDup_remove_2" [body=yes, kind=cnst, prop=yes, path="Test.ReDun", ]; N: 4 "NoDup_sind" [body=yes, kind=cnst, prop=no, path="Test.ReDun", ]; N: 93 "Permutation_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 94 "Permutation_app_head" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 87 "Permutation_app_inv" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 84 "Permutation_app_inv_l" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 83 "Permutation_app_inv_r" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 92 "Permutation_app_swap" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 95 "Permutation_app_tail" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 91 "Permutation_cons_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 85 "Permutation_cons_app_inv" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 86 "Permutation_cons_inv" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 96 "Permutation_in" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 103 "Permutation_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 88 "Permutation_ind_bis" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 90 "Permutation_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 74 "Permutation_map" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 101 "Permutation_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 100 "Permutation_nil_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 99 "Permutation_refl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 89 "Permutation_rev" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 102 "Permutation_sind" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 98 "Permutation_sym" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 97 "Permutation_trans" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 169 "app" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 156 "app_ass" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 154 "app_comm_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 158 "app_cons_not_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 153 "app_eq_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 152 "app_eq_unit" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 151 "app_inj_tail" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 147 "app_inv_head" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 146 "app_inv_tail" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 150 "app_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 157 "app_nil_end" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 136 "app_nth1" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 135 "app_nth2" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 130 "app_removelast_last" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 155 "ass_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 46 "combine" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 41 "combine_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 40 "combine_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 44 "combine_split" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 127 "count_occ" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 126 "count_occ_In" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 123 "count_occ_cons_eq" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 122 "count_occ_cons_neq" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 125 "count_occ_inv_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 124 "count_occ_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 167 "destruct_list" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 120 "distr_rev" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 129 "exists_last" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 61 "existsb" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 60 "existsb_exists" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 59 "existsb_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 56 "filter" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 55 "filter_In" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 54 "find" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 19 "firstn" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 16 "firstn_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 14 "firstn_removelast" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 17 "firstn_skipn" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 73 "flat_map" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 69 "fold_left" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 68 "fold_left_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 67 "fold_left_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 64 "fold_left_rev_right" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 66 "fold_right" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 65 "fold_right_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 63 "fold_symmetric" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 58 "forallb" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 57 "forallb_forall" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 175 "hd" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 176 "head" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 165 "head_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 166 "head_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 149 "in_app_or" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 43 "in_combine_l" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 42 "in_combine_r" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 163 "in_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 164 "in_eq" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 72 "in_flat_map" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 160 "in_inv" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 80 "in_map" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 79 "in_map_iff" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 162 "in_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 148 "in_or_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 37 "in_prod" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 38 "in_prod_aux" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 36 "in_prod_iff" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 51 "in_split_l" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 50 "in_split_r" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 27 "incl" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 20 "incl_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 23 "incl_appl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 22 "incl_appr" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 21 "incl_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 26 "incl_refl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 25 "incl_tl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 24 "incl_tran" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 132 "last" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 34 "lel" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 30 "lel_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 31 "lel_cons_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 28 "lel_nil" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 33 "lel_refl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 29 "lel_tail" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 32 "lel_trans" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 173 "length" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 82 "list_eq_dec" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 179 "list_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 62 "list_power" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 39 "list_prod" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 178 "list_rec" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 180 "list_rect" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 177 "list_sind" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 81 "map" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 76 "map_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 70 "map_ext" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 78 "map_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 71 "map_map" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 77 "map_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 75 "map_rev" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 168 "nil_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 145 "nth" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 139 "nth_In" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 142 "nth_S_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 140 "nth_default" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 141 "nth_error" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 143 "nth_in_or_default" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 137 "nth_indep" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 144 "nth_ok" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 138 "nth_overflow" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 53 "partition" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 35 "prod_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 134 "remove" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 133 "remove_In" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 131 "removelast" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 128 "removelast_app" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 15 "removelast_firstn" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 121 "rev" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 113 "rev'" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 111 "rev_alt" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 114 "rev_append" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 112 "rev_append_rev" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 109 "rev_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 118 "rev_involutive" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 116 "rev_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 110 "rev_list_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 115 "rev_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 119 "rev_unit" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 13 "seq" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 12 "seq_length" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 11 "seq_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 10 "seq_shift" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 172 "size" [body=no, kind=cnst, prop=no, path="Test", ]; N: 171 "size_nil" [body=no, kind=cnst, prop=yes, path="Test", ]; N: 18 "skipn" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 52 "split" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 45 "split_combine" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 48 "split_length_l" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 47 "split_length_r" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 49 "split_nth" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 174 "tail" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 8 "NoDup" [kind=inductive, prop=no, path="Test.ReDun", ]; N: 108 "Permutation" [kind=inductive, prop=no, path="Test", ]; N: 183 "list" [kind=inductive, prop=no, path="Test", ]; N: 7 "NoDup_nil" [kind=construct, prop=yes, path="Test.ReDun", ]; N: 107 "perm_nil" [kind=construct, prop=yes, path="Test", ]; N: 182 "nil" [kind=construct, prop=no, path="Test", ]; N: 6 "NoDup_cons" [kind=construct, prop=yes, path="Test.ReDun", ]; N: 106 "perm_skip" [kind=construct, prop=yes, path="Test", ]; N: 181 "cons" [kind=construct, prop=no, path="Test", ]; N: 105 "perm_swap" [kind=construct, prop=yes, path="Test", ]; N: 104 "perm_trans" [kind=construct, prop=yes, path="Test", ]; E: 1 2 [weight=1, ]; E: 1 3 [weight=1, ]; E: 1 8 [weight=25, ]; E: 1 9 [weight=416, ]; E: 1 91 [weight=1, ]; E: 1 107 [weight=1, ]; E: 1 108 [weight=16, ]; E: 1 148 [weight=2, ]; E: 1 149 [weight=2, ]; E: 1 161 [weight=1, ]; E: 1 169 [weight=39, ]; E: 1 170 [weight=129, ]; E: 1 179 [weight=1, ]; E: 1 181 [weight=82, ]; E: 1 182 [weight=20, ]; E: 1 183 [weight=67, ]; E: 2 8 [weight=19, ]; E: 2 9 [weight=258, ]; E: 2 148 [weight=1, ]; E: 2 169 [weight=43, ]; E: 2 170 [weight=33, ]; E: 2 179 [weight=1, ]; E: 2 181 [weight=66, ]; E: 2 182 [weight=8, ]; E: 2 183 [weight=66, ]; E: 3 6 [weight=1, ]; E: 3 8 [weight=32, ]; E: 3 9 [weight=232, ]; E: 3 148 [weight=1, ]; E: 3 149 [weight=1, ]; E: 3 169 [weight=37, ]; E: 3 170 [weight=27, ]; E: 3 179 [weight=1, ]; E: 3 181 [weight=67, ]; E: 3 182 [weight=8, ]; E: 3 183 [weight=63, ]; E: 4 8 [weight=6, ]; E: 4 9 [weight=15, ]; E: 4 170 [weight=2, ]; E: 4 181 [weight=2, ]; E: 4 182 [weight=2, ]; E: 4 183 [weight=7, ]; E: 5 8 [weight=6, ]; E: 5 9 [weight=15, ]; E: 5 170 [weight=2, ]; E: 5 181 [weight=2, ]; E: 5 182 [weight=2, ]; E: 5 183 [weight=7, ]; E: 6 9 [weight=5, ]; E: 6 170 [weight=1, ]; E: 6 181 [weight=1, ]; E: 6 182 [weight=1, ]; E: 6 183 [weight=1, ]; E: 7 9 [weight=5, ]; E: 7 170 [weight=1, ]; E: 7 181 [weight=1, ]; E: 7 182 [weight=1, ]; E: 7 183 [weight=1, ]; E: 8 9 [weight=5, ]; E: 8 170 [weight=1, ]; E: 8 181 [weight=1, ]; E: 8 182 [weight=1, ]; E: 8 183 [weight=1, ]; E: 10 13 [weight=14, ]; E: 10 81 [weight=6, ]; E: 10 181 [weight=3, ]; E: 10 182 [weight=1, ]; E: 10 183 [weight=10, ]; E: 11 13 [weight=12, ]; E: 11 145 [weight=12, ]; E: 11 181 [weight=3, ]; E: 12 13 [weight=6, ]; E: 12 173 [weight=6, ]; E: 13 181 [weight=1, ]; E: 13 182 [weight=1, ]; E: 13 183 [weight=3, ]; E: 14 19 [weight=30, ]; E: 14 128 [weight=1, ]; E: 14 131 [weight=17, ]; E: 14 169 [weight=3, ]; E: 14 173 [weight=26, ]; E: 14 181 [weight=17, ]; E: 14 182 [weight=27, ]; E: 14 183 [weight=40, ]; E: 15 19 [weight=30, ]; E: 15 128 [weight=1, ]; E: 15 131 [weight=11, ]; E: 15 169 [weight=3, ]; E: 15 173 [weight=18, ]; E: 15 181 [weight=16, ]; E: 15 182 [weight=37, ]; E: 15 183 [weight=45, ]; E: 16 19 [weight=10, ]; E: 16 173 [weight=20, ]; E: 16 181 [weight=4, ]; E: 16 182 [weight=4, ]; E: 16 183 [weight=9, ]; E: 17 18 [weight=13, ]; E: 17 19 [weight=13, ]; E: 17 169 [weight=13, ]; E: 17 181 [weight=10, ]; E: 17 182 [weight=4, ]; E: 17 183 [weight=29, ]; E: 18 182 [weight=1, ]; E: 18 183 [weight=8, ]; E: 19 181 [weight=1, ]; E: 19 182 [weight=2, ]; E: 19 183 [weight=8, ]; E: 20 27 [weight=6, ]; E: 20 149 [weight=1, ]; E: 20 169 [weight=4, ]; E: 20 170 [weight=16, ]; E: 20 183 [weight=12, ]; E: 21 27 [weight=4, ]; E: 21 170 [weight=18, ]; E: 21 181 [weight=3, ]; E: 21 183 [weight=8, ]; E: 22 27 [weight=4, ]; E: 22 148 [weight=1, ]; E: 22 169 [weight=2, ]; E: 22 170 [weight=3, ]; E: 22 183 [weight=6, ]; E: 23 27 [weight=4, ]; E: 23 148 [weight=1, ]; E: 23 169 [weight=2, ]; E: 23 170 [weight=3, ]; E: 23 183 [weight=6, ]; E: 24 27 [weight=6, ]; E: 24 170 [weight=1, ]; E: 24 183 [weight=6, ]; E: 25 27 [weight=4, ]; E: 25 163 [weight=1, ]; E: 25 170 [weight=1, ]; E: 25 181 [weight=2, ]; E: 25 183 [weight=4, ]; E: 26 27 [weight=2, ]; E: 26 170 [weight=1, ]; E: 26 183 [weight=2, ]; E: 27 170 [weight=2, ]; E: 27 183 [weight=4, ]; E: 28 34 [weight=5, ]; E: 28 173 [weight=1, ]; E: 28 179 [weight=1, ]; E: 28 181 [weight=2, ]; E: 28 182 [weight=11, ]; E: 28 183 [weight=9, ]; E: 29 34 [weight=4, ]; E: 29 173 [weight=8, ]; E: 29 181 [weight=6, ]; E: 29 183 [weight=4, ]; E: 30 34 [weight=4, ]; E: 30 173 [weight=8, ]; E: 30 181 [weight=3, ]; E: 30 183 [weight=4, ]; E: 31 34 [weight=4, ]; E: 31 173 [weight=14, ]; E: 31 181 [weight=6, ]; E: 31 183 [weight=4, ]; E: 32 34 [weight=6, ]; E: 32 173 [weight=7, ]; E: 32 183 [weight=6, ]; E: 33 34 [weight=2, ]; E: 33 173 [weight=1, ]; E: 33 183 [weight=2, ]; E: 34 173 [weight=2, ]; E: 34 183 [weight=4, ]; E: 35 39 [weight=10, ]; E: 35 78 [weight=1, ]; E: 35 81 [weight=4, ]; E: 35 150 [weight=1, ]; E: 35 169 [weight=1, ]; E: 35 173 [weight=31, ]; E: 35 179 [weight=1, ]; E: 35 181 [weight=2, ]; E: 35 182 [weight=2, ]; E: 35 183 [weight=11, ]; E: 36 37 [weight=1, ]; E: 36 39 [weight=12, ]; E: 36 79 [weight=1, ]; E: 36 81 [weight=11, ]; E: 36 149 [weight=1, ]; E: 36 169 [weight=1, ]; E: 36 170 [weight=87, ]; E: 36 179 [weight=1, ]; E: 36 181 [weight=2, ]; E: 36 182 [weight=2, ]; E: 36 183 [weight=6, ]; E: 37 38 [weight=1, ]; E: 37 39 [weight=9, ]; E: 37 81 [weight=5, ]; E: 37 148 [weight=1, ]; E: 37 170 [weight=27, ]; E: 37 179 [weight=1, ]; E: 37 181 [weight=2, ]; E: 37 182 [weight=2, ]; E: 37 183 [weight=11, ]; E: 38 81 [weight=8, ]; E: 38 170 [weight=16, ]; E: 38 179 [weight=1, ]; E: 38 181 [weight=2, ]; E: 38 182 [weight=2, ]; E: 38 183 [weight=4, ]; E: 39 81 [weight=1, ]; E: 39 169 [weight=1, ]; E: 39 182 [weight=1, ]; E: 39 183 [weight=10, ]; E: 40 46 [weight=13, ]; E: 40 145 [weight=39, ]; E: 40 173 [weight=24, ]; E: 40 179 [weight=1, ]; E: 40 181 [weight=25, ]; E: 40 182 [weight=25, ]; E: 40 183 [weight=13, ]; E: 41 46 [weight=8, ]; E: 41 173 [weight=24, ]; E: 41 179 [weight=1, ]; E: 41 181 [weight=8, ]; E: 41 182 [weight=4, ]; E: 41 183 [weight=12, ]; E: 42 46 [weight=10, ]; E: 42 170 [weight=21, ]; E: 42 179 [weight=1, ]; E: 42 181 [weight=5, ]; E: 42 182 [weight=3, ]; E: 42 183 [weight=12, ]; E: 43 46 [weight=10, ]; E: 43 170 [weight=21, ]; E: 43 179 [weight=1, ]; E: 43 181 [weight=7, ]; E: 43 182 [weight=3, ]; E: 43 183 [weight=12, ]; E: 44 46 [weight=10, ]; E: 44 52 [weight=10, ]; E: 44 173 [weight=30, ]; E: 44 179 [weight=1, ]; E: 44 181 [weight=23, ]; E: 44 182 [weight=23, ]; E: 44 183 [weight=88, ]; E: 45 46 [weight=16, ]; E: 45 52 [weight=7, ]; E: 45 179 [weight=1, ]; E: 45 181 [weight=17, ]; E: 45 182 [weight=3, ]; E: 45 183 [weight=55, ]; E: 46 181 [weight=1, ]; E: 46 182 [weight=2, ]; E: 46 183 [weight=12, ]; E: 47 52 [weight=7, ]; E: 47 173 [weight=22, ]; E: 47 179 [weight=1, ]; E: 47 181 [weight=8, ]; E: 47 182 [weight=2, ]; E: 47 183 [weight=48, ]; E: 48 52 [weight=7, ]; E: 48 173 [weight=22, ]; E: 48 179 [weight=1, ]; E: 48 181 [weight=8, ]; E: 48 182 [weight=2, ]; E: 48 183 [weight=48, ]; E: 49 52 [weight=32, ]; E: 49 145 [weight=66, ]; E: 49 179 [weight=1, ]; E: 49 181 [weight=39, ]; E: 49 182 [weight=15, ]; E: 49 183 [weight=180, ]; E: 50 52 [weight=8, ]; E: 50 170 [weight=28, ]; E: 50 179 [weight=1, ]; E: 50 181 [weight=10, ]; E: 50 182 [weight=2, ]; E: 50 183 [weight=58, ]; E: 51 52 [weight=8, ]; E: 51 170 [weight=28, ]; E: 51 179 [weight=1, ]; E: 51 181 [weight=10, ]; E: 51 182 [weight=2, ]; E: 51 183 [weight=58, ]; E: 52 181 [weight=2, ]; E: 52 182 [weight=2, ]; E: 52 183 [weight=20, ]; E: 53 181 [weight=2, ]; E: 53 182 [weight=2, ]; E: 53 183 [weight=22, ]; E: 54 183 [weight=4, ]; E: 55 56 [weight=49, ]; E: 55 170 [weight=107, ]; E: 55 179 [weight=1, ]; E: 55 181 [weight=5, ]; E: 55 182 [weight=2, ]; E: 55 183 [weight=6, ]; E: 56 181 [weight=1, ]; E: 56 182 [weight=1, ]; E: 56 183 [weight=8, ]; E: 57 58 [weight=25, ]; E: 57 170 [weight=19, ]; E: 57 179 [weight=1, ]; E: 57 181 [weight=2, ]; E: 57 182 [weight=2, ]; E: 57 183 [weight=4, ]; E: 58 183 [weight=4, ]; E: 59 61 [weight=13, ]; E: 59 145 [weight=11, ]; E: 59 173 [weight=24, ]; E: 59 179 [weight=1, ]; E: 59 181 [weight=3, ]; E: 59 182 [weight=19, ]; E: 59 183 [weight=4, ]; E: 60 61 [weight=37, ]; E: 60 170 [weight=55, ]; E: 60 179 [weight=1, ]; E: 60 181 [weight=2, ]; E: 60 182 [weight=2, ]; E: 60 183 [weight=4, ]; E: 61 183 [weight=4, ]; E: 62 73 [weight=1, ]; E: 62 81 [weight=1, ]; E: 62 181 [weight=2, ]; E: 62 182 [weight=2, ]; E: 62 183 [weight=19, ]; E: 63 66 [weight=18, ]; E: 63 69 [weight=13, ]; E: 63 179 [weight=1, ]; E: 63 181 [weight=4, ]; E: 63 182 [weight=3, ]; E: 63 183 [weight=6, ]; E: 64 65 [weight=1, ]; E: 64 66 [weight=10, ]; E: 64 69 [weight=7, ]; E: 64 121 [weight=9, ]; E: 64 169 [weight=1, ]; E: 64 179 [weight=1, ]; E: 64 181 [weight=6, ]; E: 64 182 [weight=6, ]; E: 64 183 [weight=4, ]; E: 65 66 [weight=30, ]; E: 65 169 [weight=11, ]; E: 65 179 [weight=1, ]; E: 65 181 [weight=2, ]; E: 65 182 [weight=2, ]; E: 65 183 [weight=11, ]; E: 66 183 [weight=4, ]; E: 67 69 [weight=8, ]; E: 67 173 [weight=12, ]; E: 67 179 [weight=1, ]; E: 67 181 [weight=2, ]; E: 67 182 [weight=2, ]; E: 67 183 [weight=7, ]; E: 68 69 [weight=16, ]; E: 68 169 [weight=5, ]; E: 68 179 [weight=1, ]; E: 68 181 [weight=2, ]; E: 68 182 [weight=2, ]; E: 68 183 [weight=10, ]; E: 69 183 [weight=4, ]; E: 70 81 [weight=16, ]; E: 70 179 [weight=1, ]; E: 70 181 [weight=7, ]; E: 70 182 [weight=3, ]; E: 70 183 [weight=15, ]; E: 71 81 [weight=20, ]; E: 71 179 [weight=1, ]; E: 71 181 [weight=5, ]; E: 71 182 [weight=3, ]; E: 71 183 [weight=14, ]; E: 72 73 [weight=32, ]; E: 72 148 [weight=1, ]; E: 72 149 [weight=1, ]; E: 72 169 [weight=3, ]; E: 72 170 [weight=129, ]; E: 72 179 [weight=1, ]; E: 72 181 [weight=2, ]; E: 72 182 [weight=2, ]; E: 72 183 [weight=6, ]; E: 73 169 [weight=1, ]; E: 73 182 [weight=1, ]; E: 73 183 [weight=10, ]; E: 74 81 [weight=24, ]; E: 74 103 [weight=1, ]; E: 74 104 [weight=1, ]; E: 74 105 [weight=1, ]; E: 74 106 [weight=1, ]; E: 74 107 [weight=1, ]; E: 74 108 [weight=14, ]; E: 74 181 [weight=6, ]; E: 74 182 [weight=2, ]; E: 74 183 [weight=12, ]; E: 75 76 [weight=1, ]; E: 75 81 [weight=19, ]; E: 75 121 [weight=18, ]; E: 75 169 [weight=6, ]; E: 75 179 [weight=1, ]; E: 75 181 [weight=9, ]; E: 75 182 [weight=10, ]; E: 75 183 [weight=17, ]; E: 76 81 [weight=23, ]; E: 76 169 [weight=14, ]; E: 76 179 [weight=1, ]; E: 76 181 [weight=5, ]; E: 76 182 [weight=2, ]; E: 76 183 [weight=21, ]; E: 77 81 [weight=8, ]; E: 77 145 [weight=21, ]; E: 77 179 [weight=1, ]; E: 77 181 [weight=5, ]; E: 77 182 [weight=6, ]; E: 77 183 [weight=4, ]; E: 78 81 [weight=6, ]; E: 78 173 [weight=12, ]; E: 78 179 [weight=1, ]; E: 78 181 [weight=2, ]; E: 78 182 [weight=2, ]; E: 78 183 [weight=4, ]; E: 79 81 [weight=50, ]; E: 79 170 [weight=125, ]; E: 79 179 [weight=1, ]; E: 79 181 [weight=21, ]; E: 79 182 [weight=13, ]; E: 79 183 [weight=4, ]; E: 80 81 [weight=8, ]; E: 80 170 [weight=16, ]; E: 80 179 [weight=1, ]; E: 80 181 [weight=2, ]; E: 80 182 [weight=2, ]; E: 80 183 [weight=4, ]; E: 81 181 [weight=1, ]; E: 81 182 [weight=1, ]; E: 81 183 [weight=7, ]; E: 82 168 [weight=2, ]; E: 82 180 [weight=1, ]; E: 82 181 [weight=70, ]; E: 82 182 [weight=14, ]; E: 82 183 [weight=102, ]; E: 83 87 [weight=1, ]; E: 83 108 [weight=12, ]; E: 83 157 [weight=2, ]; E: 83 169 [weight=11, ]; E: 83 179 [weight=1, ]; E: 83 181 [weight=2, ]; E: 83 182 [weight=3, ]; E: 83 183 [weight=18, ]; E: 84 86 [weight=1, ]; E: 84 108 [weight=12, ]; E: 84 169 [weight=14, ]; E: 84 179 [weight=1, ]; E: 84 181 [weight=4, ]; E: 84 182 [weight=2, ]; E: 84 183 [weight=18, ]; E: 85 87 [weight=1, ]; E: 85 108 [weight=3, ]; E: 85 169 [weight=3, ]; E: 85 181 [weight=4, ]; E: 85 182 [weight=1, ]; E: 85 183 [weight=6, ]; E: 86 87 [weight=1, ]; E: 86 108 [weight=3, ]; E: 86 181 [weight=4, ]; E: 86 182 [weight=2, ]; E: 86 183 [weight=4, ]; E: 87 88 [weight=1, ]; E: 87 91 [weight=6, ]; E: 87 96 [weight=1, ]; E: 87 98 [weight=23, ]; E: 87 99 [weight=6, ]; E: 87 104 [weight=10, ]; E: 87 105 [weight=3, ]; E: 87 106 [weight=15, ]; E: 87 108 [weight=191, ]; E: 87 148 [weight=1, ]; E: 87 161 [weight=1, ]; E: 87 169 [weight=631, ]; E: 87 170 [weight=4, ]; E: 87 181 [weight=975, ]; E: 87 182 [weight=35, ]; E: 87 183 [weight=814, ]; E: 88 99 [weight=6, ]; E: 88 103 [weight=1, ]; E: 88 105 [weight=1, ]; E: 88 108 [weight=13, ]; E: 88 179 [weight=2, ]; E: 88 181 [weight=23, ]; E: 88 182 [weight=4, ]; E: 88 183 [weight=34, ]; E: 89 92 [weight=1, ]; E: 89 97 [weight=1, ]; E: 89 98 [weight=2, ]; E: 89 99 [weight=1, ]; E: 89 106 [weight=1, ]; E: 89 108 [weight=6, ]; E: 89 121 [weight=12, ]; E: 89 169 [weight=3, ]; E: 89 179 [weight=1, ]; E: 89 181 [weight=12, ]; E: 89 182 [weight=7, ]; E: 89 183 [weight=4, ]; E: 90 103 [weight=1, ]; E: 90 108 [weight=5, ]; E: 90 173 [weight=24, ]; E: 90 181 [weight=6, ]; E: 90 182 [weight=2, ]; E: 90 183 [weight=12, ]; E: 91 99 [weight=1, ]; E: 91 104 [weight=2, ]; E: 91 105 [weight=1, ]; E: 91 106 [weight=3, ]; E: 91 108 [weight=12, ]; E: 91 169 [weight=22, ]; E: 91 179 [weight=1, ]; E: 91 181 [weight=27, ]; E: 91 182 [weight=2, ]; E: 91 183 [weight=19, ]; E: 92 97 [weight=3, ]; E: 92 98 [weight=3, ]; E: 92 99 [weight=2, ]; E: 92 105 [weight=1, ]; E: 92 106 [weight=3, ]; E: 92 108 [weight=11, ]; E: 92 154 [weight=1, ]; E: 92 157 [weight=2, ]; E: 92 169 [weight=43, ]; E: 92 179 [weight=2, ]; E: 92 181 [weight=42, ]; E: 92 182 [weight=6, ]; E: 92 183 [weight=18, ]; E: 93 94 [weight=1, ]; E: 93 95 [weight=1, ]; E: 93 97 [weight=2, ]; E: 93 98 [weight=2, ]; E: 93 103 [weight=1, ]; E: 93 105 [weight=1, ]; E: 93 106 [weight=1, ]; E: 93 108 [weight=22, ]; E: 93 154 [weight=10, ]; E: 93 169 [weight=53, ]; E: 93 181 [weight=66, ]; E: 93 183 [weight=36, ]; E: 94 106 [weight=1, ]; E: 94 108 [weight=7, ]; E: 94 154 [weight=2, ]; E: 94 169 [weight=14, ]; E: 94 179 [weight=1, ]; E: 94 181 [weight=6, ]; E: 94 183 [weight=12, ]; E: 95 97 [weight=1, ]; E: 95 98 [weight=2, ]; E: 95 99 [weight=1, ]; E: 95 103 [weight=1, ]; E: 95 105 [weight=1, ]; E: 95 106 [weight=1, ]; E: 95 108 [weight=14, ]; E: 95 169 [weight=28, ]; E: 95 181 [weight=10, ]; E: 95 182 [weight=2, ]; E: 95 183 [weight=14, ]; E: 96 103 [weight=1, ]; E: 96 108 [weight=5, ]; E: 96 170 [weight=40, ]; E: 96 181 [weight=6, ]; E: 96 182 [weight=2, ]; E: 96 183 [weight=12, ]; E: 97 104 [weight=1, ]; E: 97 108 [weight=3, ]; E: 97 183 [weight=3, ]; E: 98 103 [weight=1, ]; E: 98 104 [weight=1, ]; E: 98 105 [weight=1, ]; E: 98 106 [weight=1, ]; E: 98 107 [weight=1, ]; E: 98 108 [weight=10, ]; E: 98 183 [weight=12, ]; E: 99 106 [weight=1, ]; E: 99 107 [weight=1, ]; E: 99 108 [weight=3, ]; E: 99 179 [weight=1, ]; E: 99 183 [weight=4, ]; E: 100 101 [weight=1, ]; E: 100 108 [weight=3, ]; E: 100 168 [weight=1, ]; E: 100 181 [weight=5, ]; E: 100 182 [weight=4, ]; E: 100 183 [weight=4, ]; E: 101 103 [weight=1, ]; E: 101 108 [weight=5, ]; E: 101 168 [weight=2, ]; E: 101 181 [weight=10, ]; E: 101 182 [weight=23, ]; E: 101 183 [weight=30, ]; E: 102 108 [weight=10, ]; E: 102 181 [weight=12, ]; E: 102 182 [weight=4, ]; E: 102 183 [weight=22, ]; E: 103 108 [weight=10, ]; E: 103 181 [weight=12, ]; E: 103 182 [weight=4, ]; E: 103 183 [weight=22, ]; E: 104 181 [weight=6, ]; E: 104 182 [weight=2, ]; E: 104 183 [weight=6, ]; E: 105 181 [weight=6, ]; E: 105 182 [weight=2, ]; E: 105 183 [weight=6, ]; E: 106 181 [weight=6, ]; E: 106 182 [weight=2, ]; E: 106 183 [weight=6, ]; E: 107 181 [weight=6, ]; E: 107 182 [weight=2, ]; E: 107 183 [weight=6, ]; E: 108 181 [weight=6, ]; E: 108 182 [weight=2, ]; E: 108 183 [weight=6, ]; E: 109 110 [weight=1, ]; E: 109 118 [weight=1, ]; E: 109 121 [weight=9, ]; E: 109 169 [weight=2, ]; E: 109 181 [weight=3, ]; E: 109 182 [weight=4, ]; E: 109 183 [weight=11, ]; E: 110 121 [weight=7, ]; E: 110 179 [weight=1, ]; E: 110 181 [weight=2, ]; E: 110 182 [weight=2, ]; E: 110 183 [weight=8, ]; E: 111 112 [weight=1, ]; E: 111 114 [weight=2, ]; E: 111 121 [weight=4, ]; E: 111 157 [weight=1, ]; E: 111 169 [weight=1, ]; E: 111 182 [weight=4, ]; E: 111 183 [weight=6, ]; E: 112 114 [weight=7, ]; E: 112 121 [weight=9, ]; E: 112 155 [weight=1, ]; E: 112 169 [weight=10, ]; E: 112 179 [weight=1, ]; E: 112 181 [weight=9, ]; E: 112 182 [weight=5, ]; E: 112 183 [weight=21, ]; E: 113 114 [weight=1, ]; E: 113 182 [weight=1, ]; E: 113 183 [weight=3, ]; E: 114 181 [weight=1, ]; E: 114 183 [weight=10, ]; E: 115 116 [weight=2, ]; E: 115 121 [weight=35, ]; E: 115 135 [weight=1, ]; E: 115 136 [weight=1, ]; E: 115 145 [weight=41, ]; E: 115 169 [weight=10, ]; E: 115 173 [weight=73, ]; E: 115 179 [weight=1, ]; E: 115 181 [weight=29, ]; E: 115 182 [weight=37, ]; E: 115 183 [weight=4, ]; E: 116 121 [weight=9, ]; E: 116 150 [weight=1, ]; E: 116 169 [weight=1, ]; E: 116 173 [weight=22, ]; E: 116 179 [weight=1, ]; E: 116 181 [weight=7, ]; E: 116 182 [weight=7, ]; E: 116 183 [weight=4, ]; E: 117 121 [weight=30, ]; E: 117 148 [weight=2, ]; E: 117 149 [weight=1, ]; E: 117 169 [weight=5, ]; E: 117 170 [weight=62, ]; E: 117 179 [weight=1, ]; E: 117 181 [weight=16, ]; E: 117 182 [weight=18, ]; E: 117 183 [weight=4, ]; E: 118 119 [weight=1, ]; E: 118 121 [weight=17, ]; E: 118 169 [weight=1, ]; E: 118 179 [weight=1, ]; E: 118 181 [weight=8, ]; E: 118 182 [weight=4, ]; E: 118 183 [weight=17, ]; E: 119 120 [weight=1, ]; E: 119 121 [weight=2, ]; E: 119 169 [weight=1, ]; E: 119 181 [weight=3, ]; E: 119 182 [weight=2, ]; E: 119 183 [weight=3, ]; E: 120 121 [weight=29, ]; E: 120 156 [weight=1, ]; E: 120 157 [weight=1, ]; E: 120 169 [weight=20, ]; E: 120 179 [weight=1, ]; E: 120 181 [weight=8, ]; E: 120 182 [weight=13, ]; E: 120 183 [weight=22, ]; E: 121 169 [weight=1, ]; E: 121 181 [weight=1, ]; E: 121 182 [weight=2, ]; E: 121 183 [weight=7, ]; E: 122 127 [weight=10, ]; E: 122 181 [weight=2, ]; E: 122 183 [weight=2, ]; E: 123 127 [weight=10, ]; E: 123 181 [weight=2, ]; E: 123 183 [weight=2, ]; E: 124 127 [weight=2, ]; E: 124 182 [weight=2, ]; E: 125 127 [weight=19, ]; E: 125 179 [weight=1, ]; E: 125 181 [weight=3, ]; E: 125 182 [weight=11, ]; E: 125 183 [weight=14, ]; E: 126 127 [weight=29, ]; E: 126 170 [weight=27, ]; E: 126 179 [weight=1, ]; E: 126 181 [weight=2, ]; E: 126 182 [weight=2, ]; E: 126 183 [weight=4, ]; E: 127 183 [weight=4, ]; E: 128 131 [weight=38, ]; E: 128 169 [weight=35, ]; E: 128 179 [weight=1, ]; E: 128 181 [weight=26, ]; E: 128 182 [weight=30, ]; E: 128 183 [weight=71, ]; E: 129 169 [weight=25, ]; E: 129 180 [weight=1, ]; E: 129 181 [weight=50, ]; E: 129 182 [weight=46, ]; E: 129 183 [weight=75, ]; E: 130 131 [weight=13, ]; E: 130 132 [weight=13, ]; E: 130 169 [weight=13, ]; E: 130 179 [weight=1, ]; E: 130 181 [weight=44, ]; E: 130 182 [weight=35, ]; E: 130 183 [weight=34, ]; E: 131 181 [weight=1, ]; E: 131 182 [weight=2, ]; E: 131 183 [weight=9, ]; E: 132 183 [weight=5, ]; E: 133 134 [weight=12, ]; E: 133 170 [weight=11, ]; E: 133 179 [weight=1, ]; E: 133 181 [weight=4, ]; E: 133 182 [weight=2, ]; E: 133 183 [weight=5, ]; E: 134 181 [weight=1, ]; E: 134 182 [weight=1, ]; E: 134 183 [weight=8, ]; E: 135 145 [weight=26, ]; E: 135 169 [weight=8, ]; E: 135 173 [weight=30, ]; E: 135 179 [weight=1, ]; E: 135 181 [weight=9, ]; E: 135 182 [weight=6, ]; E: 135 183 [weight=9, ]; E: 136 145 [weight=24, ]; E: 136 169 [weight=11, ]; E: 136 173 [weight=24, ]; E: 136 179 [weight=1, ]; E: 136 181 [weight=9, ]; E: 136 182 [weight=19, ]; E: 136 183 [weight=9, ]; E: 137 145 [weight=14, ]; E: 137 173 [weight=13, ]; E: 137 179 [weight=1, ]; E: 137 181 [weight=3, ]; E: 137 182 [weight=3, ]; E: 137 183 [weight=4, ]; E: 138 145 [weight=9, ]; E: 138 173 [weight=18, ]; E: 138 179 [weight=1, ]; E: 138 181 [weight=6, ]; E: 138 182 [weight=6, ]; E: 138 183 [weight=4, ]; E: 139 145 [weight=14, ]; E: 139 170 [weight=14, ]; E: 139 173 [weight=19, ]; E: 139 181 [weight=6, ]; E: 139 182 [weight=6, ]; E: 139 183 [weight=12, ]; E: 140 141 [weight=1, ]; E: 140 183 [weight=2, ]; E: 141 183 [weight=5, ]; E: 142 145 [weight=7, ]; E: 142 170 [weight=6, ]; E: 142 181 [weight=4, ]; E: 142 183 [weight=3, ]; E: 143 145 [weight=32, ]; E: 143 170 [weight=16, ]; E: 143 178 [weight=1, ]; E: 143 181 [weight=9, ]; E: 143 182 [weight=4, ]; E: 143 183 [weight=4, ]; E: 144 183 [weight=5, ]; E: 145 183 [weight=5, ]; E: 146 150 [weight=2, ]; E: 146 169 [weight=36, ]; E: 146 173 [weight=46, ]; E: 146 179 [weight=1, ]; E: 146 181 [weight=38, ]; E: 146 182 [weight=13, ]; E: 146 183 [weight=97, ]; E: 147 169 [weight=18, ]; E: 147 179 [weight=1, ]; E: 147 181 [weight=7, ]; E: 147 182 [weight=2, ]; E: 147 183 [weight=44, ]; E: 148 169 [weight=11, ]; E: 148 170 [weight=40, ]; E: 148 179 [weight=1, ]; E: 148 181 [weight=2, ]; E: 148 182 [weight=2, ]; E: 148 183 [weight=7, ]; E: 149 169 [weight=9, ]; E: 149 170 [weight=39, ]; E: 149 179 [weight=1, ]; E: 149 181 [weight=2, ]; E: 149 182 [weight=2, ]; E: 149 183 [weight=7, ]; E: 150 169 [weight=6, ]; E: 150 173 [weight=19, ]; E: 150 179 [weight=1, ]; E: 150 181 [weight=2, ]; E: 150 182 [weight=2, ]; E: 150 183 [weight=11, ]; E: 151 158 [weight=2, ]; E: 151 169 [weight=41, ]; E: 151 179 [weight=1, ]; E: 151 181 [weight=88, ]; E: 151 182 [weight=78, ]; E: 151 183 [weight=99, ]; E: 152 157 [weight=1, ]; E: 152 158 [weight=1, ]; E: 152 169 [weight=19, ]; E: 152 181 [weight=87, ]; E: 152 182 [weight=107, ]; E: 152 183 [weight=107, ]; E: 153 169 [weight=12, ]; E: 153 181 [weight=21, ]; E: 153 182 [weight=56, ]; E: 153 183 [weight=55, ]; E: 154 169 [weight=3, ]; E: 154 181 [weight=3, ]; E: 154 183 [weight=6, ]; E: 155 156 [weight=1, ]; E: 155 169 [weight=8, ]; E: 155 183 [weight=8, ]; E: 156 169 [weight=29, ]; E: 156 179 [weight=1, ]; E: 156 181 [weight=5, ]; E: 156 182 [weight=2, ]; E: 156 183 [weight=18, ]; E: 157 169 [weight=6, ]; E: 157 179 [weight=1, ]; E: 157 181 [weight=5, ]; E: 157 182 [weight=9, ]; E: 157 183 [weight=14, ]; E: 158 169 [weight=7, ]; E: 158 181 [weight=12, ]; E: 158 182 [weight=10, ]; E: 158 183 [weight=25, ]; E: 159 162 [weight=1, ]; E: 159 170 [weight=36, ]; E: 159 178 [weight=1, ]; E: 159 181 [weight=6, ]; E: 159 182 [weight=2, ]; E: 159 183 [weight=4, ]; E: 160 170 [weight=10, ]; E: 160 181 [weight=2, ]; E: 160 183 [weight=2, ]; E: 161 169 [weight=25, ]; E: 161 170 [weight=8, ]; E: 161 179 [weight=1, ]; E: 161 181 [weight=46, ]; E: 161 182 [weight=6, ]; E: 161 183 [weight=103, ]; E: 162 170 [weight=3, ]; E: 162 182 [weight=3, ]; E: 163 170 [weight=6, ]; E: 163 181 [weight=2, ]; E: 163 183 [weight=3, ]; E: 164 170 [weight=3, ]; E: 164 181 [weight=2, ]; E: 164 183 [weight=3, ]; E: 165 176 [weight=2, ]; E: 165 181 [weight=2, ]; E: 165 183 [weight=2, ]; E: 166 176 [weight=2, ]; E: 166 182 [weight=2, ]; E: 167 180 [weight=1, ]; E: 167 181 [weight=12, ]; E: 167 182 [weight=8, ]; E: 167 183 [weight=32, ]; E: 168 181 [weight=4, ]; E: 168 182 [weight=4, ]; E: 168 183 [weight=8, ]; E: 169 181 [weight=1, ]; E: 169 183 [weight=10, ]; E: 170 183 [weight=4, ]; E: 171 172 [weight=1, ]; E: 171 182 [weight=1, ]; E: 172 183 [weight=1, ]; E: 173 183 [weight=4, ]; E: 174 182 [weight=1, ]; E: 174 183 [weight=5, ]; E: 175 183 [weight=3, ]; E: 176 183 [weight=3, ]; E: 177 181 [weight=2, ]; E: 177 182 [weight=2, ]; E: 177 183 [weight=8, ]; E: 178 180 [weight=1, ]; E: 178 181 [weight=1, ]; E: 178 182 [weight=1, ]; E: 178 183 [weight=4, ]; E: 179 181 [weight=2, ]; E: 179 182 [weight=2, ]; E: 179 183 [weight=8, ]; E: 180 181 [weight=2, ]; E: 180 182 [weight=2, ]; E: 180 183 [weight=8, ]; coq-dpdgraph-1.0-8.19/tests/graph.without.dot.oracle000066400000000000000000000544571457702451100222660ustar00rootroot00000000000000digraph tests/graph { graph [ratio=0.5] node [style=filled] Test_removelast_app [label="removelast_app", URL=, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_Permutation [label="NoDup_Permutation", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_removelast_last [label="app_removelast_last", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_remove_2 [label="NoDup_remove_2", URL=, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_remove_1 [label="NoDup_remove_1", URL=, fillcolor="#7FFFD4"] ; Test_remove_In [label="remove_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_ind [label="NoDup_ind", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_ReDun_NoDup_cons [label="NoDup_cons", URL=, fillcolor="#7FAAFF"] ; Test_ReDun_NoDup_nil [label="NoDup_nil", URL=, peripheries=3, fillcolor="#7FAAFF"] ; Test_app_nth2 [label="app_nth2", URL=, fillcolor="#7FFFD4"] ; Test_app_nth1 [label="app_nth1", URL=, fillcolor="#7FFFD4"] ; Test_nth_indep [label="nth_indep", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_seq_shift [label="seq_shift", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_overflow [label="nth_overflow", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_seq_nth [label="seq_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_In [label="nth_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_seq_length [label="seq_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nth_S_cons [label="nth_S_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_firstn_removelast [label="firstn_removelast", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_removelast_firstn [label="removelast_firstn", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_firstn_length [label="firstn_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_firstn_skipn [label="firstn_skipn", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_inv_tail [label="app_inv_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_inv_head [label="app_inv_head", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_app [label="incl_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_or_app [label="in_or_app", URL=, fillcolor="#7FFFD4"] ; Test_incl_cons [label="incl_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_app_or [label="in_app_or", URL=, fillcolor="#7FFFD4"] ; Test_incl_appr [label="incl_appr", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_length [label="app_length", URL=, fillcolor="#7FFFD4"] ; Test_incl_appl [label="incl_appl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_inj_tail [label="app_inj_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_tran [label="incl_tran", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_eq_unit [label="app_eq_unit", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_tl [label="incl_tl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_eq_nil [label="app_eq_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_incl_refl [label="incl_refl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_comm_cons [label="app_comm_cons", URL=, fillcolor="#7FFFD4"] ; Test_ass_app [label="ass_app", URL=, fillcolor="#7FFFD4"] ; Test_lel_nil [label="lel_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_ass [label="app_ass", URL=, fillcolor="#7FFFD4"] ; Test_lel_tail [label="lel_tail", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_nil_end [label="app_nil_end", URL=, fillcolor="#7FFFD4"] ; Test_lel_cons [label="lel_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_app_cons_not_nil [label="app_cons_not_nil", URL=, fillcolor="#7FFFD4"] ; Test_lel_cons_cons [label="lel_cons_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_lel_trans [label="lel_trans", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_inv [label="in_inv", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_lel_refl [label="lel_refl", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_In_split [label="In_split", URL=, fillcolor="#7FFFD4"] ; Test_in_nil [label="in_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_prod_length [label="prod_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_cons [label="in_cons", URL=, fillcolor="#7FFFD4"] ; Test_in_prod_iff [label="in_prod_iff", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_eq [label="in_eq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_prod [label="in_prod", URL=, fillcolor="#7FFFD4"] ; Test_head_cons [label="head_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_prod_aux [label="in_prod_aux", URL=, fillcolor="#7FFFD4"] ; Test_head_nil [label="head_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_nil_cons [label="nil_cons", URL=, fillcolor="#7FFFD4"] ; Test_combine_nth [label="combine_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_combine_length [label="combine_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_combine_r [label="in_combine_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_size_nil [label="size_nil", URL=, peripheries=3, fillcolor="#FFB57F"] ; Test_in_combine_l [label="in_combine_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_combine_split [label="combine_split", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split_combine [label="split_combine", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split_length_r [label="split_length_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split_length_l [label="split_length_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_split_nth [label="split_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_split_r [label="in_split_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_list_ind [label="list_ind", URL=, fillcolor="#7FFFD4"] ; Test_in_split_l [label="in_split_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_filter_In [label="filter_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_forallb_forall [label="forallb_forall", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_existsb_nth [label="existsb_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_existsb_exists [label="existsb_exists", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_symmetric [label="fold_symmetric", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_left_rev_right [label="fold_left_rev_right", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_right_app [label="fold_right_app", URL=, fillcolor="#7FFFD4"] ; Test_fold_left_length [label="fold_left_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_fold_left_app [label="fold_left_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_ext [label="map_ext", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_map [label="map_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_in_flat_map [label="in_flat_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_map [label="Permutation_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_rev [label="map_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_app [label="map_app", URL=, fillcolor="#7FFFD4"] ; Test_map_nth [label="map_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_map_length [label="map_length", URL=, fillcolor="#7FFFD4"] ; Test_in_map_iff [label="in_map_iff", URL=, fillcolor="#7FFFD4"] ; Test_in_map [label="in_map", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_app_inv_r [label="Permutation_app_inv_r", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_app_inv_l [label="Permutation_app_inv_l", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_app_inv [label="Permutation_cons_app_inv", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_inv [label="Permutation_cons_inv", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_inv [label="Permutation_app_inv", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_ind_bis [label="Permutation_ind_bis", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_rev [label="Permutation_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_length [label="Permutation_length", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_cons_app [label="Permutation_cons_app", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_swap [label="Permutation_app_swap", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app [label="Permutation_app", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_app_head [label="Permutation_app_head", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_tail [label="Permutation_app_tail", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_in [label="Permutation_in", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_trans [label="Permutation_trans", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_sym [label="Permutation_sym", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_refl [label="Permutation_refl", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_nil_cons [label="Permutation_nil_cons", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_nil [label="Permutation_nil", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_ind [label="Permutation_ind", URL=, fillcolor="#7FFFD4"] ; Test_perm_trans [label="perm_trans", URL=, fillcolor="#7FAAFF"] ; Test_perm_swap [label="perm_swap", URL=, fillcolor="#7FAAFF"] ; Test_perm_skip [label="perm_skip", URL=, fillcolor="#7FAAFF"] ; Test_perm_nil [label="perm_nil", URL=, fillcolor="#7FAAFF"] ; Test_rev_ind [label="rev_ind", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_list_ind [label="rev_list_ind", URL=, fillcolor="#7FFFD4"] ; Test_rev_alt [label="rev_alt", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_append_rev [label="rev_append_rev", URL=, fillcolor="#7FFFD4"] ; Test_rev_nth [label="rev_nth", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_length [label="rev_length", URL=, fillcolor="#7FFFD4"] ; Test_In_rev [label="In_rev", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_rev_involutive [label="rev_involutive", URL=, fillcolor="#7FFFD4"] ; Test_rev_unit [label="rev_unit", URL=, fillcolor="#7FFFD4"] ; Test_distr_rev [label="distr_rev", URL=, fillcolor="#7FFFD4"] ; Test_count_occ_cons_neq [label="count_occ_cons_neq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_cons_eq [label="count_occ_cons_eq", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_nil [label="count_occ_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_inv_nil [label="count_occ_inv_nil", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_count_occ_In [label="count_occ_In", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_removelast_app -> Test_list_ind [] ; Test_ReDun_NoDup_Permutation -> Test_ReDun_NoDup_remove_2 [] ; Test_ReDun_NoDup_Permutation -> Test_ReDun_NoDup_remove_1 [] ; Test_ReDun_NoDup_Permutation -> Test_Permutation_cons_app [] ; Test_ReDun_NoDup_Permutation -> Test_In_split [] ; Test_app_removelast_last -> Test_list_ind [] ; Test_ReDun_NoDup_remove_2 -> Test_in_or_app [] ; Test_ReDun_NoDup_remove_1 -> Test_ReDun_NoDup_cons [] ; Test_ReDun_NoDup_remove_1 -> Test_in_or_app [] ; Test_ReDun_NoDup_remove_1 -> Test_in_app_or [] ; Test_remove_In -> Test_list_ind [] ; Test_app_nth2 -> Test_list_ind [] ; Test_app_nth1 -> Test_list_ind [] ; Test_nth_indep -> Test_list_ind [] ; Test_nth_overflow -> Test_list_ind [] ; Test_firstn_removelast -> Test_removelast_app [] ; Test_removelast_firstn -> Test_removelast_app [] ; Test_app_inv_tail -> Test_app_length [] ; Test_app_inv_head -> Test_list_ind [] ; Test_incl_app -> Test_in_app_or [] ; Test_in_or_app -> Test_list_ind [] ; Test_in_app_or -> Test_list_ind [] ; Test_incl_appr -> Test_in_or_app [] ; Test_app_length -> Test_list_ind [] ; Test_incl_appl -> Test_in_or_app [] ; Test_app_inj_tail -> Test_app_cons_not_nil [] ; Test_app_inj_tail -> Test_list_ind [] ; Test_app_eq_unit -> Test_app_nil_end [] ; Test_app_eq_unit -> Test_app_cons_not_nil [] ; Test_incl_tl -> Test_in_cons [] ; Test_ass_app -> Test_app_ass [] ; Test_lel_nil -> Test_list_ind [] ; Test_app_ass -> Test_list_ind [] ; Test_app_nil_end -> Test_list_ind [] ; Test_In_split -> Test_list_ind [] ; Test_prod_length -> Test_map_length [] ; Test_prod_length -> Test_app_length [] ; Test_in_prod_iff -> Test_in_prod [] ; Test_in_prod_iff -> Test_in_map_iff [] ; Test_in_prod_iff -> Test_in_app_or [] ; Test_in_prod -> Test_in_prod_aux [] ; Test_in_prod -> Test_in_or_app [] ; Test_in_prod_aux -> Test_list_ind [] ; Test_combine_nth -> Test_list_ind [] ; Test_combine_length -> Test_list_ind [] ; Test_in_combine_r -> Test_list_ind [] ; Test_in_combine_l -> Test_list_ind [] ; Test_combine_split -> Test_list_ind [] ; Test_split_combine -> Test_list_ind [] ; Test_split_length_r -> Test_list_ind [] ; Test_split_length_l -> Test_list_ind [] ; Test_split_nth -> Test_list_ind [] ; Test_in_split_r -> Test_list_ind [] ; Test_in_split_l -> Test_list_ind [] ; Test_filter_In -> Test_list_ind [] ; Test_forallb_forall -> Test_list_ind [] ; Test_existsb_nth -> Test_list_ind [] ; Test_existsb_exists -> Test_list_ind [] ; Test_fold_symmetric -> Test_list_ind [] ; Test_fold_left_rev_right -> Test_fold_right_app [] ; Test_fold_right_app -> Test_list_ind [] ; Test_fold_left_length -> Test_list_ind [] ; Test_fold_left_app -> Test_list_ind [] ; Test_map_ext -> Test_list_ind [] ; Test_map_map -> Test_list_ind [] ; Test_in_flat_map -> Test_in_or_app [] ; Test_in_flat_map -> Test_in_app_or [] ; Test_Permutation_map -> Test_Permutation_ind [] ; Test_Permutation_map -> Test_perm_trans [] ; Test_Permutation_map -> Test_perm_swap [] ; Test_Permutation_map -> Test_perm_skip [] ; Test_Permutation_map -> Test_perm_nil [] ; Test_map_rev -> Test_map_app [] ; Test_map_app -> Test_list_ind [] ; Test_map_nth -> Test_list_ind [] ; Test_map_length -> Test_list_ind [] ; Test_in_map_iff -> Test_list_ind [] ; Test_in_map -> Test_list_ind [] ; Test_Permutation_app_inv_r -> Test_Permutation_app_inv [] ; Test_Permutation_app_inv_r -> Test_app_nil_end [] ; Test_Permutation_app_inv_l -> Test_Permutation_cons_inv [] ; Test_Permutation_cons_app_inv -> Test_Permutation_app_inv [] ; Test_Permutation_cons_inv -> Test_Permutation_app_inv [] ; Test_Permutation_app_inv -> Test_Permutation_ind_bis [] ; Test_Permutation_app_inv -> Test_Permutation_cons_app [] ; Test_Permutation_app_inv -> Test_Permutation_in [] ; Test_Permutation_app_inv -> Test_Permutation_sym [] ; Test_Permutation_app_inv -> Test_in_or_app [] ; Test_Permutation_app_inv -> Test_In_split [] ; Test_Permutation_ind_bis -> Test_Permutation_refl [] ; Test_Permutation_ind_bis -> Test_Permutation_ind [] ; Test_Permutation_ind_bis -> Test_perm_swap [] ; Test_Permutation_rev -> Test_Permutation_app_swap [] ; Test_Permutation_length -> Test_Permutation_ind [] ; Test_Permutation_cons_app -> Test_Permutation_refl [] ; Test_Permutation_cons_app -> Test_perm_trans [] ; Test_Permutation_cons_app -> Test_perm_swap [] ; Test_Permutation_app_swap -> Test_Permutation_trans [] ; Test_Permutation_app_swap -> Test_Permutation_sym [] ; Test_Permutation_app_swap -> Test_Permutation_refl [] ; Test_Permutation_app_swap -> Test_app_comm_cons [] ; Test_Permutation_app_swap -> Test_app_nil_end [] ; Test_Permutation_app -> Test_Permutation_app_head [] ; Test_Permutation_app -> Test_Permutation_app_tail [] ; Test_Permutation_app_head -> Test_perm_skip [] ; Test_Permutation_app_head -> Test_app_comm_cons [] ; Test_Permutation_app_head -> Test_list_ind [] ; Test_Permutation_app_tail -> Test_Permutation_trans [] ; Test_Permutation_app_tail -> Test_Permutation_sym [] ; Test_Permutation_app_tail -> Test_Permutation_refl [] ; Test_Permutation_in -> Test_Permutation_ind [] ; Test_Permutation_trans -> Test_perm_trans [] ; Test_Permutation_sym -> Test_Permutation_ind [] ; Test_Permutation_sym -> Test_perm_trans [] ; Test_Permutation_sym -> Test_perm_swap [] ; Test_Permutation_sym -> Test_perm_skip [] ; Test_Permutation_sym -> Test_perm_nil [] ; Test_Permutation_refl -> Test_perm_skip [] ; Test_Permutation_refl -> Test_perm_nil [] ; Test_Permutation_refl -> Test_list_ind [] ; Test_Permutation_nil_cons -> Test_Permutation_nil [] ; Test_Permutation_nil -> Test_Permutation_ind [] ; Test_Permutation_nil -> Test_nil_cons [] ; Test_rev_ind -> Test_rev_list_ind [] ; Test_rev_ind -> Test_rev_involutive [] ; Test_rev_list_ind -> Test_list_ind [] ; Test_rev_alt -> Test_rev_append_rev [] ; Test_rev_alt -> Test_app_nil_end [] ; Test_rev_append_rev -> Test_ass_app [] ; Test_rev_nth -> Test_rev_length [] ; Test_rev_nth -> Test_app_nth2 [] ; Test_rev_nth -> Test_app_nth1 [] ; Test_rev_length -> Test_app_length [] ; Test_In_rev -> Test_in_or_app [] ; Test_In_rev -> Test_in_app_or [] ; Test_rev_involutive -> Test_rev_unit [] ; Test_rev_unit -> Test_distr_rev [] ; Test_distr_rev -> Test_app_ass [] ; Test_distr_rev -> Test_app_nil_end [] ; Test_count_occ_inv_nil -> Test_list_ind [] ; Test_count_occ_In -> Test_list_ind [] ; subgraph cluster_Test { label="Test"; fillcolor="#FFFFC3"; labeljust=l; style=filled subgraph cluster_Test_ReDun { label="ReDun"; fillcolor="#FFFFA3"; labeljust=l; style=filled Test_ReDun_NoDup_nil; Test_ReDun_NoDup_cons; Test_ReDun_NoDup_ind; Test_ReDun_NoDup_remove_1; Test_ReDun_NoDup_remove_2; Test_ReDun_NoDup_Permutation; }; Test_count_occ_In; Test_count_occ_inv_nil; Test_count_occ_nil; Test_count_occ_cons_eq; Test_count_occ_cons_neq; Test_distr_rev; Test_rev_unit; Test_rev_involutive; Test_In_rev; Test_rev_length; Test_rev_nth; Test_rev_append_rev; Test_rev_alt; Test_rev_list_ind; Test_rev_ind; Test_perm_nil; Test_perm_skip; Test_perm_swap; Test_perm_trans; Test_Permutation_ind; Test_Permutation_nil; Test_Permutation_nil_cons; Test_Permutation_refl; Test_Permutation_sym; Test_Permutation_trans; Test_Permutation_in; Test_Permutation_app_tail; Test_Permutation_app_head; Test_Permutation_app; Test_Permutation_app_swap; Test_Permutation_cons_app; Test_Permutation_length; Test_Permutation_rev; Test_Permutation_ind_bis; Test_Permutation_app_inv; Test_Permutation_cons_inv; Test_Permutation_cons_app_inv; Test_Permutation_app_inv_l; Test_Permutation_app_inv_r; Test_in_map; Test_in_map_iff; Test_map_length; Test_map_nth; Test_map_app; Test_map_rev; Test_Permutation_map; Test_in_flat_map; Test_map_map; Test_map_ext; Test_fold_left_app; Test_fold_left_length; Test_fold_right_app; Test_fold_left_rev_right; Test_fold_symmetric; Test_existsb_exists; Test_existsb_nth; Test_forallb_forall; Test_filter_In; Test_in_split_l; Test_list_ind; Test_in_split_r; Test_split_nth; Test_split_length_l; Test_split_length_r; Test_split_combine; Test_combine_split; Test_in_combine_l; Test_size_nil; Test_in_combine_r; Test_combine_length; Test_combine_nth; Test_nil_cons; Test_head_nil; Test_in_prod_aux; Test_head_cons; Test_in_prod; Test_in_eq; Test_in_prod_iff; Test_in_cons; Test_prod_length; Test_in_nil; Test_In_split; Test_lel_refl; Test_in_inv; Test_lel_trans; Test_lel_cons_cons; Test_app_cons_not_nil; Test_lel_cons; Test_app_nil_end; Test_lel_tail; Test_app_ass; Test_lel_nil; Test_ass_app; Test_app_comm_cons; Test_incl_refl; Test_app_eq_nil; Test_incl_tl; Test_app_eq_unit; Test_incl_tran; Test_app_inj_tail; Test_incl_appl; Test_app_length; Test_incl_appr; Test_in_app_or; Test_incl_cons; Test_in_or_app; Test_incl_app; Test_app_inv_head; Test_app_inv_tail; Test_firstn_skipn; Test_firstn_length; Test_removelast_firstn; Test_firstn_removelast; Test_nth_S_cons; Test_seq_length; Test_nth_In; Test_seq_nth; Test_nth_overflow; Test_seq_shift; Test_nth_indep; Test_app_nth1; Test_app_nth2; Test_remove_In; Test_app_removelast_last; Test_removelast_app; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/graph2.dot.oracle000066400000000000000000000103071457702451100206300ustar00rootroot00000000000000digraph tests/graph2 { graph [ratio=0.5] node [style=filled] Test_Permutation_app_swap [label="Permutation_app_swap", URL=, peripheries=3, fillcolor="#7FFFD4"] ; Test_Permutation_sym [label="Permutation_sym", URL=, fillcolor="#7FFFD4"] ; Test_app_nil_end [label="app_nil_end", URL=, fillcolor="#7FFFD4"] ; Test_app_comm_cons [label="app_comm_cons", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_refl [label="Permutation_refl", URL=, fillcolor="#7FFFD4"] ; Test_list_ind [label="list_ind", URL=, fillcolor="#7FFFD4"] ; _eq_ind [label="eq_ind", URL=<.html#eq_ind>, fillcolor="#7FFFD4"] ; _eq_ind_r [label="eq_ind_r", URL=<.html#eq_ind_r>, fillcolor="#7FFFD4"] ; Test_Permutation_trans [label="Permutation_trans", URL=, fillcolor="#7FFFD4"] ; Test_app [label="app", URL=, fillcolor="#F070D1"] ; Test_Permutation [label="Permutation", URL=, fillcolor="#E2CDFA"] ; Test_list [label="list", URL=, fillcolor="#E2CDFA"] ; Test_perm_skip [label="perm_skip", URL=, fillcolor="#7FAAFF"] ; Test_perm_swap [label="perm_swap", URL=, fillcolor="#7FAAFF"] ; Test_nil [label="nil", URL=, fillcolor="#7FAAFF"] ; Test_cons [label="cons", URL=, fillcolor="#7FAAFF"] ; Test_perm_trans [label="perm_trans", URL=, fillcolor="#7FAAFF"] ; _eq_sym [label="eq_sym", URL=<.html#eq_sym>, fillcolor="#7FFFD4"] ; _eq [label="eq", URL=<.html#eq>, fillcolor="#E2CDFA"] ; _eq_refl [label="eq_refl", URL=<.html#eq_refl>, fillcolor="#7FAAFF"] ; Test_perm_nil [label="perm_nil", URL=, fillcolor="#7FAAFF"] ; Test_Permutation_ind [label="Permutation_ind", URL=, fillcolor="#7FFFD4"] ; Test_Permutation_app_swap -> Test_Permutation_sym [] ; Test_Permutation_app_swap -> Test_app_nil_end [] ; Test_Permutation_app_swap -> Test_app_comm_cons [] ; Test_Permutation_app_swap -> Test_Permutation_refl [] ; Test_Permutation_app_swap -> _eq_ind_r [] ; Test_Permutation_app_swap -> Test_Permutation_trans [] ; Test_Permutation_sym -> Test_perm_skip [] ; Test_Permutation_sym -> Test_perm_swap [] ; Test_Permutation_sym -> Test_perm_trans [] ; Test_Permutation_sym -> Test_perm_nil [] ; Test_Permutation_sym -> Test_Permutation_ind [] ; Test_app_nil_end -> Test_list_ind [] ; Test_app_nil_end -> _eq_ind [] ; Test_app_nil_end -> Test_app [] ; Test_app_nil_end -> _eq_refl [] ; Test_app_comm_cons -> Test_app [] ; Test_app_comm_cons -> _eq [] ; Test_app_comm_cons -> _eq_refl [] ; Test_Permutation_refl -> Test_list_ind [] ; Test_Permutation_refl -> Test_Permutation [] ; Test_Permutation_refl -> Test_perm_skip [] ; Test_Permutation_refl -> Test_perm_nil [] ; Test_list_ind -> Test_list [] ; Test_list_ind -> Test_nil [] ; Test_list_ind -> Test_cons [] ; _eq_ind -> _eq [] ; _eq_ind_r -> _eq_ind [] ; _eq_ind_r -> _eq_sym [] ; Test_Permutation_trans -> Test_Permutation [] ; Test_Permutation_trans -> Test_perm_trans [] ; Test_app -> Test_list [] ; Test_app -> Test_cons [] ; Test_Permutation -> Test_list [] ; Test_Permutation -> Test_nil [] ; Test_Permutation -> Test_cons [] ; Test_perm_skip -> Test_list [] ; Test_perm_skip -> Test_nil [] ; Test_perm_skip -> Test_cons [] ; Test_perm_swap -> Test_list [] ; Test_perm_swap -> Test_nil [] ; Test_perm_swap -> Test_cons [] ; Test_perm_trans -> Test_list [] ; Test_perm_trans -> Test_nil [] ; Test_perm_trans -> Test_cons [] ; _eq_sym -> _eq [] ; _eq_sym -> _eq_refl [] ; Test_perm_nil -> Test_list [] ; Test_perm_nil -> Test_nil [] ; Test_perm_nil -> Test_cons [] ; Test_Permutation_ind -> Test_Permutation [] ; subgraph cluster_Test { label="Test"; fillcolor="#FFFFC3"; labeljust=l; style=filled Test_Permutation_ind; Test_perm_nil; Test_perm_trans; Test_cons; Test_nil; Test_perm_swap; Test_perm_skip; Test_list; Test_Permutation; Test_app; Test_Permutation_trans; Test_list_ind; Test_Permutation_refl; Test_app_comm_cons; Test_app_nil_end; Test_Permutation_sym; Test_Permutation_app_swap; }; } /* END */ coq-dpdgraph-1.0-8.19/tests/graph2.dpd.oracle000066400000000000000000000061741457702451100206200ustar00rootroot00000000000000N: 184 "Permutation_app_swap" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 205 "Permutation_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 188 "Permutation_refl" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 185 "Permutation_sym" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 192 "Permutation_trans" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 193 "app" [body=yes, kind=cnst, prop=no, path="Test", ]; N: 187 "app_comm_cons" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 186 "app_nil_end" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 190 "eq_ind" [body=yes, kind=cnst, prop=yes, ]; N: 191 "eq_ind_r" [body=yes, kind=cnst, prop=yes, ]; N: 201 "eq_sym" [body=yes, kind=cnst, prop=yes, ]; N: 189 "list_ind" [body=yes, kind=cnst, prop=yes, path="Test", ]; N: 194 "Permutation" [kind=inductive, prop=no, path="Test", ]; N: 202 "eq" [kind=inductive, prop=no, ]; N: 195 "list" [kind=inductive, prop=no, path="Test", ]; N: 204 "perm_nil" [kind=construct, prop=yes, path="Test", ]; N: 203 "eq_refl" [kind=construct, prop=yes, ]; N: 198 "nil" [kind=construct, prop=no, path="Test", ]; N: 196 "perm_skip" [kind=construct, prop=yes, path="Test", ]; N: 199 "cons" [kind=construct, prop=no, path="Test", ]; N: 197 "perm_swap" [kind=construct, prop=yes, path="Test", ]; N: 200 "perm_trans" [kind=construct, prop=yes, path="Test", ]; E: 184 185 [weight=3, ]; E: 184 186 [weight=2, ]; E: 184 187 [weight=1, ]; E: 184 188 [weight=2, ]; E: 184 189 [weight=2, ]; E: 184 190 [weight=2, ]; E: 184 191 [weight=1, ]; E: 184 192 [weight=3, ]; E: 184 193 [weight=43, ]; E: 184 194 [weight=11, ]; E: 184 195 [weight=18, ]; E: 184 196 [weight=3, ]; E: 184 197 [weight=1, ]; E: 184 198 [weight=6, ]; E: 184 199 [weight=42, ]; E: 185 194 [weight=10, ]; E: 185 195 [weight=12, ]; E: 185 196 [weight=1, ]; E: 185 197 [weight=1, ]; E: 185 200 [weight=1, ]; E: 185 204 [weight=1, ]; E: 185 205 [weight=1, ]; E: 186 189 [weight=1, ]; E: 186 190 [weight=1, ]; E: 186 193 [weight=6, ]; E: 186 195 [weight=14, ]; E: 186 198 [weight=9, ]; E: 186 199 [weight=5, ]; E: 186 202 [weight=6, ]; E: 186 203 [weight=2, ]; E: 187 193 [weight=3, ]; E: 187 195 [weight=6, ]; E: 187 199 [weight=3, ]; E: 187 202 [weight=1, ]; E: 187 203 [weight=1, ]; E: 188 189 [weight=1, ]; E: 188 194 [weight=3, ]; E: 188 195 [weight=4, ]; E: 188 196 [weight=1, ]; E: 188 204 [weight=1, ]; E: 189 195 [weight=8, ]; E: 189 198 [weight=2, ]; E: 189 199 [weight=2, ]; E: 190 202 [weight=3, ]; E: 191 190 [weight=1, ]; E: 191 201 [weight=1, ]; E: 191 202 [weight=2, ]; E: 192 194 [weight=3, ]; E: 192 195 [weight=3, ]; E: 192 200 [weight=1, ]; E: 193 195 [weight=10, ]; E: 193 199 [weight=1, ]; E: 194 195 [weight=6, ]; E: 194 198 [weight=2, ]; E: 194 199 [weight=6, ]; E: 196 195 [weight=6, ]; E: 196 198 [weight=2, ]; E: 196 199 [weight=6, ]; E: 197 195 [weight=6, ]; E: 197 198 [weight=2, ]; E: 197 199 [weight=6, ]; E: 200 195 [weight=6, ]; E: 200 198 [weight=2, ]; E: 200 199 [weight=6, ]; E: 201 202 [weight=5, ]; E: 201 203 [weight=1, ]; E: 204 195 [weight=6, ]; E: 204 198 [weight=2, ]; E: 204 199 [weight=6, ]; E: 205 194 [weight=10, ]; E: 205 195 [weight=22, ]; E: 205 198 [weight=4, ]; E: 205 199 [weight=12, ]; coq-dpdgraph-1.0-8.19/tests/graph2.dpdusage.oracle000066400000000000000000000000771457702451100216410ustar00rootroot00000000000000Info: read file tests/graph2.dpd Test:Permutation_app_swap (0) coq-dpdgraph-1.0-8.19/tests/lexing.err.dpd000066400000000000000000000000571457702451100202400ustar00rootroot00000000000000N: 1 "one"; N: 2 "two" ! N: 4 "four"; E: 1 3; coq-dpdgraph-1.0-8.19/tests/lexing.err.oracle000066400000000000000000000001331457702451100207310ustar00rootroot00000000000000Info: read file tests/lexing.err.dpd Error: (line:2, character:11): illegal character '!'. coq-dpdgraph-1.0-8.19/tests/missing_node.err.dpd000066400000000000000000000000561457702451100214270ustar00rootroot00000000000000N: 1 "one"; N: 2 "two"; N: 4 "four"; E: 1 3; coq-dpdgraph-1.0-8.19/tests/missing_node.err.oracle000066400000000000000000000001341457702451100221220ustar00rootroot00000000000000Info: read file tests/missing_node.err.dpd Error: no node with number 3: cannot build edge. coq-dpdgraph-1.0-8.19/tests/parsing.err.dpd000066400000000000000000000000621457702451100204110ustar00rootroot00000000000000N: 1 "one"; N: 2 "two" xyz; N: 4 "four"; E: 1 3; coq-dpdgraph-1.0-8.19/tests/parsing.err.oracle000066400000000000000000000001261457702451100211100ustar00rootroot00000000000000Info: read file tests/parsing.err.dpd Error: parsing error (line:2, character:11-14). coq-dpdgraph-1.0-8.19/tests/search.cmd000066400000000000000000000001411457702451100174160ustar00rootroot00000000000000Require Import dpdgraph.dpdgraph. Require Import Test. SearchDepend Test.Permutation_app_swap. coq-dpdgraph-1.0-8.19/tests/search.oracle000066400000000000000000000006051457702451100201250ustar00rootroot00000000000000Welcome to Coq [Loading ML file coq-dpdgraph.plugin ... done] [Loading ML file ring_plugin.cmxs (using legacy method) ... done] Fetching opaque proofs from disk for dpdgraph.tests.Test [cons(42) nil(6) perm_swap(1) perm_skip(3) list(18) Permutation(11) app(43) Permutation_trans(3) eq_ind_r(1) eq_ind(2) list_ind(2) Permutation_refl(2) app_comm_cons(1) app_nil_end(2) Permutation_sym(3) ] coq-dpdgraph-1.0-8.19/tests/unterminated_comment.err.dpd000066400000000000000000000000611457702451100231660ustar00rootroot00000000000000N: 1 "one"; N: 2 "two"; N: 4 "four"; /* E: 1 3; coq-dpdgraph-1.0-8.19/tests/unterminated_comment.err.oracle000066400000000000000000000001661457702451100236720ustar00rootroot00000000000000Info: read file tests/unterminated_comment.err.dpd Error: unterminated comment (started near (line:3, character:13)). coq-dpdgraph-1.0-8.19/version.mli000066400000000000000000000001161457702451100165140ustar00rootroot00000000000000(* This file is generated by Makefile. Do not modify. *) val version : string