packages feed

dedukti (empty) → 1.0.0

raw patch · 44 files changed

+3825/−0 lines, 44 filesdep +Streamdep +basedep +bytestringsetup-changed

Dependencies added: Stream, base, bytestring, containers, directory, filepath, haskell-src-exts, hmk, mtl, parsec, process, text, time, wl-pprint

Files

+ COPYING view
@@ -0,0 +1,674 @@+                    GNU GENERAL PUBLIC LICENSE+                       Version 3, 29 June 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++                            Preamble++  The GNU General Public License is a free, copyleft license for+software and other kinds of works.++  The licenses for most software and other practical works are designed+to take away your freedom to share and change the works.  By contrast,+the GNU General Public License is intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.  We, the Free Software Foundation, use the+GNU General Public License for most of our software; it applies also to+any other work released this way by its authors.  You can apply it to+your programs, too.++  When we speak of free software, we are referring to freedom, 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+them if you wish), that you receive source code or can get it if you+want it, that you can change the software or use pieces of it in new+free programs, and that you know you can do these things.++  To protect your rights, we need to prevent others from denying you+these rights or asking you to surrender the rights.  Therefore, you have+certain responsibilities if you distribute copies of the software, or if+you modify it: responsibilities to respect the freedom of others.++  For example, if you distribute copies of such a program, whether+gratis or for a fee, you must pass on to the recipients the same+freedoms that you received.  You must make sure that they, too, receive+or can get the source code.  And you must show them these terms so they+know their rights.++  Developers that use the GNU GPL protect your rights with two steps:+(1) assert copyright on the software, and (2) offer you this License+giving you legal permission to copy, distribute and/or modify it.++  For the developers' and authors' protection, the GPL clearly explains+that there is no warranty for this free software.  For both users' and+authors' sake, the GPL requires that modified versions be marked as+changed, so that their problems will not be attributed erroneously to+authors of previous versions.++  Some devices are designed to deny users access to install or run+modified versions of the software inside them, although the manufacturer+can do so.  This is fundamentally incompatible with the aim of+protecting users' freedom to change the software.  The systematic+pattern of such abuse occurs in the area of products for individuals to+use, which is precisely where it is most unacceptable.  Therefore, we+have designed this version of the GPL to prohibit the practice for those+products.  If such problems arise substantially in other domains, we+stand ready to extend this provision to those domains in future versions+of the GPL, as needed to protect the freedom of users.++  Finally, every program is threatened constantly by software patents.+States should not allow patents to restrict development and use of+software on general-purpose computers, but in those that do, we wish to+avoid the special danger that patents applied to a free program could+make it effectively proprietary.  To prevent this, the GPL assures that+patents cannot be used to render the program non-free.++  The precise terms and conditions for copying, distribution and+modification follow.++                       TERMS AND CONDITIONS++  0. Definitions.++  "This License" refers to version 3 of the GNU General Public License.++  "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++  "The Program" refers to any copyrightable work licensed under this+License.  Each licensee is addressed as "you".  "Licensees" and+"recipients" may be individuals or organizations.++  To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy.  The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++  A "covered work" means either the unmodified Program or a work based+on the Program.++  To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy.  Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++  To "convey" a work means any kind of propagation that enables other+parties to make or receive copies.  Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++  An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License.  If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++  1. Source Code.++  The "source code" for a work means the preferred form of the work+for making modifications to it.  "Object code" means any non-source+form of a work.++  A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++  The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form.  A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++  The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities.  However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work.  For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++  The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++  The Corresponding Source for a work in source code form is that+same work.++  2. Basic Permissions.++  All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met.  This License explicitly affirms your unlimited+permission to run the unmodified Program.  The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work.  This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++  You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force.  You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright.  Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++  Conveying under any other circumstances is permitted solely under+the conditions stated below.  Sublicensing is not allowed; section 10+makes it unnecessary.++  3. Protecting Users' Legal Rights From Anti-Circumvention Law.++  No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++  When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++  4. Conveying Verbatim Copies.++  You may convey verbatim copies of the Program's source code as you+receive it, in any medium, provided that you conspicuously and+appropriately publish on each copy an appropriate copyright notice;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++  You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++  5. Conveying Modified Source Versions.++  You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++    a) The work must carry prominent notices stating that you modified+    it, and giving a relevant date.++    b) The work must carry prominent notices stating that it is+    released under this License and any conditions added under section+    7.  This requirement modifies the requirement in section 4 to+    "keep intact all notices".++    c) You must license the entire work, as a whole, under this+    License to anyone who comes into possession of a copy.  This+    License will therefore apply, along with any applicable section 7+    additional terms, to the whole of the work, and all its parts,+    regardless of how they are packaged.  This License gives no+    permission to license the work in any other way, but it does not+    invalidate such permission if you have separately received it.++    d) If the work has interactive user interfaces, each must display+    Appropriate Legal Notices; however, if the Program has interactive+    interfaces that do not display Appropriate Legal Notices, your+    work need not make them do so.++  A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit.  Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++  6. Conveying Non-Source Forms.++  You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++    a) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by the+    Corresponding Source fixed on a durable physical medium+    customarily used for software interchange.++    b) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by a+    written offer, valid for at least three years and valid for as+    long as you offer spare parts or customer support for that product+    model, to give anyone who possesses the object code either (1) a+    copy of the Corresponding Source for all the software in the+    product that is covered by this License, on a durable physical+    medium customarily used for software interchange, for a price no+    more than your reasonable cost of physically performing this+    conveying of source, or (2) access to copy the+    Corresponding Source from a network server at no charge.++    c) Convey individual copies of the object code with a copy of the+    written offer to provide the Corresponding Source.  This+    alternative is allowed only occasionally and noncommercially, and+    only if you received the object code with such an offer, in accord+    with subsection 6b.++    d) Convey the object code by offering access from a designated+    place (gratis or for a charge), and offer equivalent access to the+    Corresponding Source in the same way through the same place at no+    further charge.  You need not require recipients to copy the+    Corresponding Source along with the object code.  If the place to+    copy the object code is a network server, the Corresponding Source+    may be on a different server (operated by you or a third party)+    that supports equivalent copying facilities, provided you maintain+    clear directions next to the object code saying where to find the+    Corresponding Source.  Regardless of what server hosts the+    Corresponding Source, you remain obligated to ensure that it is+    available for as long as needed to satisfy these requirements.++    e) Convey the object code using peer-to-peer transmission, provided+    you inform other peers where the object code and Corresponding+    Source of the work are being offered to the general public at no+    charge under subsection 6d.++  A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++  A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling.  In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage.  For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product.  A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++  "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source.  The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++  If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information.  But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++  The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed.  Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++  Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++  7. Additional Terms.++  "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law.  If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++  When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it.  (Additional permissions may be written to require their own+removal in certain cases when you modify the work.)  You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++  Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++    a) Disclaiming warranty or limiting liability differently from the+    terms of sections 15 and 16 of this License; or++    b) Requiring preservation of specified reasonable legal notices or+    author attributions in that material or in the Appropriate Legal+    Notices displayed by works containing it; or++    c) Prohibiting misrepresentation of the origin of that material, or+    requiring that modified versions of such material be marked in+    reasonable ways as different from the original version; or++    d) Limiting the use for publicity purposes of names of licensors or+    authors of the material; or++    e) Declining to grant rights under trademark law for use of some+    trade names, trademarks, or service marks; or++    f) Requiring indemnification of licensors and authors of that+    material by anyone who conveys the material (or modified versions of+    it) with contractual assumptions of liability to the recipient, for+    any liability that these contractual assumptions directly impose on+    those licensors and authors.++  All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10.  If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term.  If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++  If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++  Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++  8. Termination.++  You may not propagate or modify a covered work except as expressly+provided under this License.  Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++  However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++  Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++  Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License.  If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++  9. Acceptance Not Required for Having Copies.++  You are not required to accept this License in order to receive or+run a copy of the Program.  Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance.  However,+nothing other than this License grants you permission to propagate or+modify any covered work.  These actions infringe copyright if you do+not accept this License.  Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++  10. Automatic Licensing of Downstream Recipients.++  Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License.  You are not responsible+for enforcing compliance by third parties with this License.++  An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations.  If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++  You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License.  For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++  11. Patents.++  A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based.  The+work thus licensed is called the contributor's "contributor version".++  A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version.  For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++  Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++  In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement).  To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++  If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients.  "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++  If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++  A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License.  You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++  Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++  12. No Surrender of Others' Freedom.++  If 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 convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all.  For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++  13. Use with the GNU Affero General Public License.++  Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU Affero General Public License into a single+combined work, and to convey the resulting work.  The terms of this+License will continue to apply to the part which is the covered work,+but the special requirements of the GNU Affero General Public License,+section 13, concerning interaction through a network will apply to the+combination as such.++  14. Revised Versions of this License.++  The Free Software Foundation may publish revised and/or new versions of+the GNU 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+Program specifies that a certain numbered version of the GNU General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation.  If the Program does not specify a version number of the+GNU General Public License, you may choose any version ever published+by the Free Software Foundation.++  If the Program specifies that a proxy can decide which future+versions of the GNU General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++  Later license versions may give you additional or different+permissions.  However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++  15. Disclaimer of Warranty.++  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. Limitation of Liability.++  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF+SUCH DAMAGES.++  17. Interpretation of Sections 15 and 16.++  If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++                     END OF TERMS AND CONDITIONS++            How to Apply These Terms to Your New Programs++  If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms.++  To do so, attach the following notices to the program.  It is safest+to attach them to the start of each source file to most effectively+state the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++    <one line to give the program's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    This program is free software: you can redistribute it and/or modify+    it under the terms of the GNU General Public License as published by+    the Free Software Foundation, either version 3 of the License, or+    (at your option) any later version.++    This program 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 General Public License for more details.++    You should have received a copy of the GNU General Public License+    along with this program.  If not, see <http://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++  If the program does terminal interaction, make it output a short+notice like this when it starts in an interactive mode:++    <program>  Copyright (C) <year>  <name of author>+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.+    This is free software, and you are welcome to redistribute it+    under certain conditions; type `show c' for details.++The hypothetical commands `show w' and `show c' should show the appropriate+parts of the General Public License.  Of course, your program's commands+might be different; for a GUI interface, you would use an "about box".++  You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU GPL, see+<http://www.gnu.org/licenses/>.++  The GNU General Public License does not permit incorporating your program+into proprietary programs.  If your program is a subroutine library, you+may consider it more useful to permit linking proprietary applications with+the library.  If this is what you want to do, use the GNU Lesser General+Public License instead of this License.  But first, please read+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+ Dedukti.hs view
@@ -0,0 +1,85 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- This module is the entry point for europa. Based on the command line+-- arguments the appropriate driver is invoked. Everything is coordinated by+-- the driver. This module is also the place where global configuration data+-- is initialized.+module Main where++import System.Environment+import qualified Dedukti.Config as Config+import Dedukti.DkM+import Dedukti.Module+import Dedukti.Driver.Batch+import Dedukti.Driver.Compile+import Text.PrettyPrint.Leijen+import Control.Monad (unless, when)+import System.Console.GetOpt+import System.Exit+import System.IO+import qualified Data.Text.Lazy.Encoding as T+import qualified Data.Text.Lazy as T+import qualified Data.ByteString.Lazy as B+++data Flag = FlagMake | FlagHelp | FlagVersion | FlagVerbose | FlagVeryVerbose+            deriving (Eq, Ord, Show)++options = [ Option [] ["make"] (NoArg FlagMake)+                       "Build MODULE and all its dependencies in one go."+          , Option ['v'] [] (OptArg verb "v")+                       "Be verbose. -vv to be even more verbose."+          , Option ['h'] ["help"] (NoArg FlagHelp) "This usage information."+          , Option [] ["version"] (NoArg FlagVersion) "Output version information then exit." ]+    where verb Nothing = FlagVerbose+          verb (Just "v") = FlagVeryVerbose+          verb _ = error "Unrecognized verbosity level."++printUsage = do+  self <- parameter Config.imageName+  let header = show $ text "Usage:" <+>+               (text self <+> text "[OPTION]..." <+> text "MODULE")+  io $ hPutStrLn stderr header++printHelp = do+  self <- parameter Config.imageName+  let header = show $ text "Usage:" <+>+               (text self <+> text "[OPTION]..." <+> text "MODULE")+               <$> text "Options:"+  io $ putStrLn (usageInfo header options)++bailout = printUsage >> io exitFailure++printVersion = do+  self <- parameter Config.imageName+  version <- parameter Config.version+  io $ B.putStrLn $ T.encodeUtf8 $ T.pack $ flip displayS "" $ renderPretty 0.70 100 $+     text "Dedukti" <+> text version <> line <> line <>+     text "Copyright (c) 2009 CNRS - École Polytechnique - INRIA." <> line <> line <>+     fillText "You may redistribute copies of Dedukti under the terms of \+              \the GNU General Public License. For more information about \+              \these matters, see the file named COPYING."++initializeConfiguration = foldr aux Config.defaultConfig+    where aux FlagVerbose c     = c { Config.verbosity = Verbose }+          aux FlagVeryVerbose c = c { Config.verbosity = Debug }+          aux _ c               = c++main = do+  args <- getArgs+  let (opts, files, errs) = getOpt RequireOrder options args+  when (not (null errs)) $ do+         hPutDoc stderr (vsep (map text errs))+         exitFailure+  runDkM (initializeConfiguration opts) $+         case undefined of+           _ | FlagHelp `elem` opts -> printHelp+             | FlagVersion `elem` opts -> printVersion+           _ | FlagMake `elem` opts -> do+                     unless (length files == 1) bailout+                     make [moduleFromPath (head files)]+             | otherwise -> do+                     unless (length files == 1) bailout+                     compile (moduleFromPath (head files))
+ Dedukti/Analysis/Dependency.hs view
@@ -0,0 +1,17 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Find all direct dependencies of the current module.++module Dedukti.Analysis.Dependency where++import Dedukti.Core+import Dedukti.Module+import qualified Data.Set as Set+++collectDependencies :: Module Qid a -> [MName]+collectDependencies drs =+    Set.toList $ Set.fromList [ m | Var x _ <- everyone drs+                                  , Just m <- return (provenance x) ]
+ Dedukti/Analysis/Rule.hs view
@@ -0,0 +1,39 @@+module Dedukti.Analysis.Rule where++import Dedukti.Core+import Dedukti.Module+import Dedukti.DkM+import qualified Dedukti.Rule as Rule+import Dedukti.Pretty ()+import Text.PrettyPrint.Leijen hiding (group)+import Data.List (group, sort)+++newtype NonContiguousRules = NonContiguousRules Qid+    deriving (Eq, Ord, Typeable)++instance Show NonContiguousRules where+    show (NonContiguousRules id) =+        show (text "Rules for" <+> pretty id <+> text "should be given contiguously.")++instance Exception NonContiguousRules++checkOrdering :: [TyRule Qid a] -> DkM ()+checkOrdering rules = do+  mapM_ (\x -> when (length x > 1) (throw $ NonContiguousRules (head x))) $+        group $ sort $ map head $ group $ map Rule.headConstant rules++newtype BadPattern = BadPattern [Qid]+    deriving (Eq, Ord, Typeable)++instance Show BadPattern where+    show (BadPattern ids) =+        let ppvars = sep (punctuate comma (map pretty ids))+        in show (text "Pattern variables" <+> ppvars <+> text "cannot appear in constructor position.")++instance Exception BadPattern++checkHead :: TyRule Qid a -> DkM ()+checkHead (env :@ lhs :--> rhs) =+    let bad = [ x | App (Var x _) _ _ <- everyone lhs, x `isin` env ]+    in when (not (null bad)) $ throw (BadPattern bad)
+ Dedukti/Analysis/Scope.hs view
@@ -0,0 +1,76 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Check that all occurrences of variables are in scope of their definitions.+-- Other well-formedness checks can also be found here, such as rejecting+-- duplicate top-level definitions and enforcing contiguity of rule+-- defnitions.++module Dedukti.Analysis.Scope where++import Dedukti.Core+import Dedukti.Module+import qualified Dedukti.Rule as Rule+import Dedukti.Pretty ()+import Dedukti.DkM+import Data.List (sort, group)+import qualified Data.Set as Set+++newtype DuplicateDefinition = DuplicateDefinition Qid+    deriving (Eq, Ord, Typeable)++instance Show DuplicateDefinition where+    show (DuplicateDefinition id) =+        show (text "duplicate definition" <+> pretty id)++instance Exception DuplicateDefinition++newtype ScopeError = ScopeError Qid+    deriving (Eq, Ord, Typeable)++instance Show ScopeError where+    show (ScopeError id) = show (pretty id <+> text "not in scope.")++instance Exception ScopeError++newtype IllegalEnvironment = IllegalEnvironment Qid+    deriving (Eq, Ord, Typeable)++instance Show IllegalEnvironment where+    show (IllegalEnvironment id) = show (pretty id <+> text "appears in environment but not in head of rule.")++instance Exception IllegalEnvironment++checkUniqueness :: Module Qid a -> DkM ()+checkUniqueness (decls, rules) = do+  chk decls+  mapM_ (\(env :@ _) -> chk (env_bindings env)) rules+    where chk bs = mapM_ (\x -> when (length x > 1)+                                (throw $ DuplicateDefinition (head x))) $+                   group $ sort $ map bind_name bs++checkScopes :: forall a. Show a => Set.Set Qid -> Module Qid a -> DkM ()+checkScopes env (decls, rules) = do+  topenv <- foldM chkBinding env decls+  mapM_ (chkRule topenv) rules+    where chkBinding env (x ::: ty) = do+            chkExpr env ty+            return $ Set.insert x env+          chkRule topenv r@(env :@ rule) = do+            let lhsvars = Set.fromList [ x | Var x _ <- everyone (Rule.head r) ]+            mapM_ (\x -> when (x `Set.notMember` lhsvars) $+                         throw (IllegalEnvironment x)) (map bind_name $ env_bindings env)+            ruleenv <- foldM chkBinding topenv $ env_bindings env+            descendM (chkExpr (topenv `Set.union` ruleenv)) rule+          chkExpr env t@(Var x _) = do+            when (x `Set.notMember` env) (throw $ ScopeError x)+            return (t :: Expr Qid a)+          chkExpr env (Lam (x ::: ty) t _) = do+            chkExpr env ty+            chkExpr (Set.insert x env) t+          chkExpr env (Pi (x ::: ty) t _)  = do+            chkExpr env ty+            chkExpr (Set.insert x env) t+          chkExpr env t = descendM (chkExpr env) t
+ Dedukti/CodeGen.hs view
@@ -0,0 +1,26 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Interface for all code generators.+module Dedukti.CodeGen (CodeGen(..)) where++import Dedukti.Core+import Dedukti.Module+import qualified Data.Text.Lazy as T+++class CodeGen o where+    data Bundle o++    -- | Emit code corresponding to an individual rule set.+    emit :: RuleSet (Id o) (A o) -> o++    coalesce :: [o] -> Bundle o++    -- | Produce the byte sequence to write to a file, given the code+    -- for all the rule sets.+    serialize :: MName   -- ^ The module name+              -> [MName] -- ^ Dependencies+              -> Bundle o -- ^ Code+              -> T.Text
+ Dedukti/CodeGen/Exts.hs view
@@ -0,0 +1,231 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- A code generator based on the haskell-src-exts package by Niklas Broberg.++module Dedukti.CodeGen.Exts+    (module Dedukti.CodeGen, Code) where++import Dedukti.CodeGen+import Dedukti.Core+import Dedukti.Module+import Dedukti.Pretty+import qualified Dedukti.Rule as Rule+import qualified Language.Haskell.Exts.Syntax as Hs+import Language.Haskell.Exts.Pretty+import qualified Data.Text.Lazy as T+import Data.Char (toUpper)+import qualified Data.Stream as Stream+import Prelude hiding ((*))+++type Em a = a (Id Record) (A Record)++type instance Id Record = Qid+type instance A  Record = Unannot++-- External view of record.+type Code = Record++-- Create a record for each declaration in the source.+data Record = Rec { rec_name    :: Qid+                  , rec_rules   :: Int -- ^ Number of rules associated with qid.+                  , rec_code    :: [Hs.Decl] }++instance CodeGen Record where+    data Bundle Record = Bundle [Hs.Decl]++    emit rs@(RS x ty rules) =+        Rec x (length rules) (function rs : def_ty : def_box : zipWith defs_rule [0..] rules)+        where def_ty  = value (x .$ "ty") (code ty)+              def_box = value (x .$ "box")+                                     (primbbox (term ty) (var (x .$ "ty")) (var x))+              -- Checking rules involves much of the same work as checking all+              -- declarations at top-level, so let's just call the code+              -- generation functions recursively.+              defs_rule n (env :@ lhs :--> rhs) =+                  let rec (x ::: ty) rs = (emit (RS x ty []) :: Record) : rs+                      Bundle decls = coalesce $ foldr rec [ruleCheck] (env_bindings env)+                  in  Hs.FunBind [Hs.Match (*) (varName (x .$ "rule" .$ T.pack (show n)))+                                  []+                                  Nothing+                                  (Hs.UnGuardedRhs (primitiveVar "main" []))+                                  (Hs.BDecls decls)]+                      where ruleCheck = Rec (qid "rule") 0+                                            [value (qid "rule" .$ "box")+                                             (primitiveVar "checkRule" [term lhs, term rhs])]++    coalesce records = Bundle $ concatMap rec_code records ++ [main]+        where main = Hs.FunBind [Hs.Match (*) (Hs.Ident "main") []+                                       Nothing (Hs.UnGuardedRhs checks) (Hs.BDecls [])]+              checks = Hs.Do (concatMap rules records ++ map declaration records)+              declaration rec = Hs.Qualifier (primitiveVar "checkDeclaration"+                                              [ Hs.Lit $ Hs.String $ show $ pretty $ unqualify $ rec_name rec+                                              , var (rec_name rec .$ "box") ])+              rules (Rec _ 0 _) = []+              rules (Rec x nr _) =+                  [Hs.Qualifier $ primitiveVar "putStrLn" [Hs.Lit $ Hs.String ("Starting rule " ++ show (pretty (unqualify x)))]] +++                  map (\n -> Hs.Qualifier $ var (x .$ "rule" .$ T.pack (show n))) [0..nr-1] +++                  [Hs.Qualifier $ primitiveVar "putStrLn" [Hs.Lit $ Hs.String ("Finished rule " ++ show (pretty (unqualify x)))]]++    serialize mod deps (Bundle decls) =+        T.pack $ prettyPrintWithMode defaultMode {layout = PPInLine} $+        Hs.Module (*) (modname mod) [] Nothing Nothing imports decls+        where imports = runtime : map (\m -> Hs.ImportDecl (*) (modname m) True False Nothing Nothing Nothing) deps+              runtime = Hs.ImportDecl (*) (Hs.ModuleName "Dedukti.Runtime") False False Nothing Nothing Nothing+              modname m = Hs.ModuleName $ T.unpack $ T.intercalate "." $ map capitalize $ toList m++-- | A similar encoding of names as the z-encoding of GHC. Non-letter+-- characters are escaped with an x.+xencode :: Qid -> String+xencode qid =+    T.unpack $+     joinQ (qid_qualifier qid) `T.append`+     -- Prepend all idents with an x to avoid clash with runtime functions.+     T.cons 'x' (enc (qid_stem qid)) `T.append`+     joinS (qid_suffix qid)+        where joinQ Root = ""+              joinQ (h :. x) = joinQ h `T.append` capitalize x `T.append` "."+              joinS Root = ""+              joinS (h :. x) = joinS h `T.append` "_" `T.append` x+              enc = T.concatMap f where+                  f 'x'  = "xx"+                  f '\'' = "xq"+                  f '_'  = "xu"+                  f x | x >= '0', x <= '9' = 'x' `T.cons` T.singleton x+                      | otherwise = T.singleton x++function :: Em RuleSet -> Hs.Decl+function (RS x _ []) =+    Hs.FunBind [Hs.Match (*) (varName x) [] Nothing (Hs.UnGuardedRhs (primCon x)) (Hs.BDecls [])]+function (RS x _ rs) =+    Hs.FunBind [Hs.Match (*) (varName x) [] Nothing (Hs.UnGuardedRhs rhs) (Hs.BDecls [f])]+    where n = Rule.arity (head rs)+          rhs = foldr primLam+                (application (Hs.Var (Hs.UnQual (Hs.Ident "__")) : Stream.take n variables))+                (Stream.take n pvariables)+          f | n > 0     = Hs.FunBind (map clause rs ++ [defaultClause x n])+            | otherwise = Hs.FunBind (map clause rs)++clause :: Em TyRule -> Hs.Match+clause rule =+    let (lrule@(env :@ _ :--> rhs), constraints) = Rule.linearize qids rule+    in if null constraints+       then Hs.Match (*) (Hs.Ident "__") (map (pattern env) (Rule.patterns lrule))+            Nothing (Hs.UnGuardedRhs (code rhs)) (Hs.BDecls [])+       else Hs.Match (*) (Hs.Ident "__") (map (pattern env) (Rule.patterns lrule))+            Nothing (Hs.GuardedRhss [Hs.GuardedRhs (*) (guards constraints) (code rhs)]) (Hs.BDecls [])+    where guards constraints =+              map (\(x, x') -> Hs.Qualifier $+                   primitiveVar "convertible" [Hs.Lit (Hs.Int 0), var x, var x']) constraints+          qids = Stream.unfold (\i -> ((qid $ T.pack $ show i) .$ "fresh", i + 1)) 0++defaultClause :: Id Record -> Int -> Hs.Match+defaultClause x n =+    Hs.Match (*) (Hs.Ident "__") (Stream.take n pvariables) Nothing+          (Hs.UnGuardedRhs (primApps x (Stream.take n variables))) (Hs.BDecls [])++value :: Id Record -> Hs.Exp -> Hs.Decl+value x rhs =+    Hs.FunBind [Hs.Match (*) (varName x) [] Nothing (Hs.UnGuardedRhs rhs) (Hs.BDecls [])]+++pattern :: Em Env -> Em Expr -> Hs.Pat+pattern env (Var x _) | x `isin` env = pvar x+pattern env expr = case unapply expr of+                     Var x _ : xs -> primAppsP x (map (pattern env) xs)++-- | Turn an expression into object code with types erased.+code :: Em Expr -> Hs.Exp+code (Var x _)            = var x+code (Lam (x ::: ty) t _) = primLam (pvar x) (code t)+code (Lam (Hole ty) t _)  = primLam Hs.PWildCard (code t)+code (Pi (x ::: ty) t _)  = primPi (code ty) (pvar x) (code t)+code (Pi (Hole ty) t _)   = primPi (code ty) Hs.PWildCard (code t)+code (App t1 t2 _)        = primap (code t1) (code t2)+code Type                 = primType++-- | Turn a term into its Haskell representation, including all types.+term :: Em Expr -> Hs.Exp+term (Var x _)     = var (x .$ "box")+term (Lam b t _)   = primTLam b (term t)+term (Pi b t _)    = primTPi  b (term t)+term (App t1 t2 _) = primTApp (term t1) (primUBox (term t2) (code t2))+term Type          = primTType+term Kind          = primTKind++(*) :: Hs.SrcLoc+(*) = Hs.SrcLoc "" 0 0++varName :: Id Record -> Hs.Name+varName = Hs.Ident . xencode . unqualify++-- | Smart variable constructor.+var :: Id Record -> Hs.Exp+var = Hs.Var . Hs.UnQual . Hs.Ident . xencode++pvar :: Id Record -> Hs.Pat+pvar = Hs.PVar . varName++-- | Produce a set of variables y1, ..., yn+variables =+    Stream.unfold (\i -> (Hs.Var $ Hs.UnQual $ Hs.Ident $ ('y':) $ show i, i + 1)) 0++pvariables =+    Stream.unfold (\i -> (Hs.PVar $ Hs.Ident $ ('y':) $ show i, i + 1)) 0++application :: [Hs.Exp] -> Hs.Exp+application = foldl1 Hs.App++-- Primitives++primitiveVar s [] = Hs.Var $ Hs.UnQual $ Hs.Ident s+primitiveVar s xs = Hs.Paren $ application $ (Hs.Var $ Hs.UnQual $ Hs.Ident s) : xs++primitiveCon s [] = Hs.Con $ Hs.UnQual $ Hs.Ident s+primitiveCon s xs = Hs.Paren $ application $ (Hs.Con $ Hs.UnQual $ Hs.Ident s) : xs++primap  t1 t2 = primitiveVar "ap"  [t1, t2]+primApp t1 t2 = primitiveCon "App" [t1, t2]+primCon c     = primitiveCon "Con" [Hs.Lit (Hs.String (show (pretty c)))]+primType      = primitiveCon "Type" []++primLam pat t = primitiveCon "Lam" [Hs.Paren (Hs.Lambda (*) [pat] t)]+primPi  dom pat range = primitiveCon "Pi" [dom, Hs.Paren (Hs.Lambda (*) [pat] range)]++primApps c = foldl primApp (primCon c)++typedAbstraction c b t =+    let (pat, ty, ran) =+            case b of+              x ::: ty -> ( pvar (x .$ "box")+                          , ty+                          , Hs.Let (Hs.BDecls [value x (primobj (var (x .$ "box")))]) t )+              Hole ty  -> (Hs.PWildCard, ty, t)+        dom = if isVariable ty+              then term ty else primsbox (term ty) primType (code ty)+    in primitiveCon c [dom, Hs.Paren (Hs.Lambda (*) [pat] ran)]++primTLam       = typedAbstraction "TLam"+primTPi        = typedAbstraction "TPi"+primTApp t1 t2 = primitiveCon "TApp" [t1, t2]+primTType      = primitiveCon "TType" []+primTKind      = primitiveCon "TKind" []++primUBox ty obj_code         = primitiveCon "UBox" [ty, obj_code]+primbbox ty ty_code obj_code = primitiveVar "bbox" [ty, ty_code, obj_code]+primsbox ty ty_code obj_code = primitiveVar "sbox" [ty, ty_code, obj_code]++primobj t = primitiveVar "obj" [t]++-- | Build a pattern matching a constant.+primConP c = Hs.PParen $ Hs.PApp (Hs.UnQual $ Hs.Ident "Con") [Hs.PLit (Hs.String (show (pretty c)))]+primAppP t1 t2 = Hs.PParen $ Hs.PApp (Hs.UnQual $ Hs.Ident "App") [t1, t2]+primAppsP c = foldl primAppP (primConP c)++-- | Capitalize a word.+capitalize :: T.Text -> T.Text+capitalize s = case T.uncons s of+             Nothing -> T.empty+             Just (x, xs) -> toUpper x `T.cons` xs
+ Dedukti/Config.hs view
@@ -0,0 +1,27 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Global site-specific configuration variables.++module Dedukti.Config where+++data Verbosity = Quiet | Verbose | Debug+                 deriving (Eq, Ord, Show)++data Config = Config+    { homeDir :: FilePath+    , imageName :: FilePath+    , version :: String+    , hsCompiler :: FilePath+    , verbosity :: Verbosity+    }++defaultConfig =+    Config { homeDir = "."+           , imageName = "dedukti"+           , hsCompiler = "ghc"+           , version = "0.1"+           , verbosity = Quiet }+
+ Dedukti/Core.hs view
@@ -0,0 +1,281 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL++module Dedukti.Core+    ( -- * Terms+      Expr(..), Binding(..)+    -- * Rules+    , Rule(..), Env, TyRule(..), RuleSet(..)+    -- * Type Synonyms+    , Module+    -- * Type functions+    , Id, A+    -- * Convenience functions+    , (.->)+    , bind_name, bind_type+    , isAbstraction, isApplication, isVariable, isAtomic, isApplicative+    -- * Environments+    , emptyEnv, env_bindings, env_domain, env_codomain, (&), (!), isin+    -- * Annotations+    , Unannot, nann, (%%), (%%%), (<%%>), (<%%%>)+    -- * Smart constructors+    , abstract, apply, unapply+    -- * Transformations+    , Transform(..), transform, descend+    -- * Query+    , everyone+    ) where++import Control.Applicative+import Control.Monad.Identity+import Control.Monad.State+import qualified Data.Map as Map+++data Expr id a = Lam (Binding id a) (Expr id a) a+               | Pi  (Binding id a) (Expr id a) a+               | App (Expr id a) (Expr id a) a+               | Var id a+               | Type+               | Kind+                 deriving (Eq, Ord, Show)++infix 2 :::++-- | A type decorating a variable, or a type on its own.+data Binding id a = id ::: Expr id a+               | Hole (Expr id a)+                 deriving (Eq, Ord, Show)++-- | A rewrite rule.+data Rule id a = Expr id a :--> Expr id a+                 deriving (Eq, Ord, Show)+infix 9 :-->++-- | An environment is and *ordered* list of bindings, since types can depend+-- on items defined earlier in environment. We opt for a hybrid+-- representation, for both fast membership tests and conservation of order.+data Env id a = Env [Binding id a] (Map.Map id (Expr id a))+                deriving (Eq, Ord, Show)++-- | A rewrite rule paired with a typing environment.+data TyRule id a = Env id a :@ Rule id a+                 deriving (Eq, Ord, Show)+infix 8 :@++-- | A set of rewrite rules sharing a same head constant.+-- Invariant:+--+-- > all ((== rs_name ruleset) . headConstant) (rs_rules ruleset)+data RuleSet id a = RS { rs_name :: id+                       , rs_type :: Expr id a+                       , rs_rules :: [TyRule id a] }+                    deriving (Eq, Ord, Show)++type Module id a = ([Binding id a], [TyRule id a])++type family Id t+type family A t++type instance Id (Module id a) = id+type instance Id (Binding id a) = id+type instance Id (Rule id a) = id+type instance Id (TyRule id a) = id+type instance Id (RuleSet id a) = id+type instance Id (Expr id a) = id++type instance A  (Module id a) = a+type instance A  (Binding id a) = a+type instance A  (Rule id a) = a+type instance A  (TyRule id a) = a+type instance A  (RuleSet id a) = a+type instance A  (Expr id a) = a++x .-> y = Pi (Hole x) y+infixr .->++bind_type (x ::: ty) = ty+bind_type (Hole ty) = ty++bind_name (x ::: _) = x+bind_name (Hole _) = error "Binding has no name."++isAbstraction (Lam _ _ _) = True+isAbstraction (Pi _ _ _)  = True+isAbstraction _           = False++isApplication (App _ _ _) = True+isApplication _           = False++isVariable (Var _ _) = True+isVariable _         = False++isAtomic (Var _ _) = True+isAtomic Type      = True+isAtomic Kind      = True+isAtomic _         = False++isApplicative x = isAtomic x || isApplication x++env_bindings (Env bs _) = bs+env_domain (Env bs map) = Map.keys map+env_codomain (Env bs map) = Map.elems map++infix 1 &++emptyEnv = Env [] Map.empty++-- | Extend an environment with a new binding.+(&) :: Ord id => Binding id a -> Env id a -> Env id a+x ::: ty & Env bs map = Env ((x ::: ty) : bs) (Map.insert x ty map)++(!) :: Ord id => Env id a -> id -> Expr id a+Env _ map ! x = map Map.! x++isin :: Ord id => id -> Env id a -> Bool+isin x (Env _ map) = Map.member x map++fromBindings :: Ord id => [Binding id a] -> Env id a+fromBindings = foldr (&) (Env [] Map.empty)++-- | Phantom type used to express no annotation.+data Unannot = Unannot deriving (Eq, Ord, Show)++-- | Unannot should stay abstract. |nann| constructs a value of type |Unannot|.+nann = Unannot++-- | Annotation operator.+(%%) :: (a -> Expr id a) -> a -> Expr id a+(%%) = ($)++-- | Apply annotations to an annotation expecting context.+(%%%) :: ([a] -> Expr id a) -> [a] -> Expr id a+(%%%) = ($)++-- | Applicative annotation operator.+(<%%>) :: Applicative f => f (a -> Expr id a) -> a -> f (Expr id a)+x <%%> a = x <*> pure a++-- | Applicative multi-annotation operator.+(<%%%>) :: Applicative f => f ([a] -> Expr id a) -> [a] -> f (Expr id a)+x <%%%> a = x <*> pure a++infixl 1 %%+infixl 1 %%%+infixl 1 <%%>+infixl 1 <%%%>++-- | Invariant: in abstract xs t annots, length annots == length xs.+abstract :: [Binding id a] -> Expr id a -> [a] -> Expr id a+abstract [] t _ = t+abstract (x:xs) t (a:annots) = Lam x (abstract xs t annots) %% a+abstract _ _ _ = error "Fewer annotations than number of variables."++-- | Invariant: in apply ts annots, length annots == length ts - 1.+apply :: Expr id a -> [Expr id a] -> [a] -> Expr id a+apply t [] _ = t+apply t (x:xs) (a:annots) = apply (App t x %% a) xs annots+apply _ _ _= error "Fewer annotations than number of applications."++-- | Turn nested applications into a list.+unapply :: Expr id a -> [Expr id a]+unapply = reverse . aux where+    aux (App t1 t2 _) = t2 : aux t1+    aux t = [t]++class Ord (Id t) => Transform t where+    -- | Effectful bottom-up transformation on terms.+    transformM :: (Monad m, Ord (Id t)) => (Expr (Id t) (A t) -> m (Expr (Id t) (A t))) -> t -> m t++    -- | Helper function for top-down transformations.+    descendM :: (Monad m, Ord (Id t)) => (Expr (Id t) (A t) -> m (Expr (Id t) (A t))) -> t -> m t++instance Ord id => Transform (Module id a) where+    transformM f (decls, rules) =+        return (,) `ap` mapM (transformM f) decls `ap` mapM (transformM f) rules++    descendM f (decls, rules) =+        return (,) `ap` mapM (descendM f) decls `ap` mapM (descendM f) rules++instance Ord id => Transform (Binding id a) where+    transformM f (x ::: ty) = return (x :::) `ap` transformM f ty+    transformM f (Hole ty) = return Hole `ap` transformM f ty++    descendM f (x ::: ty) = return (x :::) `ap` f ty+    descendM f (Hole ty) = return Hole `ap` f ty++instance Ord id => Transform (TyRule id a) where+    transformM f (env :@ rule) =+        return (:@) `ap` (return fromBindings `ap` mapM (transformM f) (env_bindings env)) `ap`+               transformM f rule++    descendM f (env :@ rule) =+        return (:@) `ap` (return fromBindings `ap` mapM (descendM f) (env_bindings env)) `ap`+               descendM f rule++instance Ord id => Transform (Rule id a) where+    transformM f (lhs :--> rhs) =+        return (:-->) `ap` transformM f lhs `ap` transformM f rhs+    descendM f (lhs :--> rhs) = return (:-->) `ap` f lhs `ap` f rhs++instance Ord id => Transform (RuleSet id a) where+    transformM f RS{..} =+        return RS `ap` return rs_name `ap` transformM f rs_type `ap` mapM (transformM f) rs_rules++    descendM f RS{..} =+        return RS `ap` return rs_name `ap` descendM f rs_type `ap` mapM (descendM f) rs_rules++instance Ord id => Transform (Expr id a) where+    transformM f (Lam (x ::: ty) t a) = do+      ty' <- transformM f ty+      t' <- transformM f t+      f $ Lam (x ::: ty') t' a+    transformM f (Lam (Hole ty) t a) = do+      ty' <- transformM f ty+      t' <- transformM f t+      f $ Lam (Hole ty') t' a+    transformM f (Pi (x ::: ty) t a) = do+      ty' <- transformM f ty+      t' <- transformM f t+      f $ Pi (x ::: ty') t' a+    transformM f (Pi (Hole ty) t a) = do+      ty' <- transformM f ty+      t' <- transformM f t+      f $ Pi (Hole ty') t' a+    transformM f (App t1 t2 a) = do+      f =<< return App `ap` transformM f t1 `ap` transformM f t2 `ap` return a+    transformM f t = f t++    descendM f (Lam (x ::: ty) t a) = do+      ty' <- f ty+      t' <- f t+      return $ Lam (x ::: ty') t' a+    descendM f (Lam (Hole ty) t a) = do+      ty' <- f ty+      t' <-  f t+      return $ Lam (Hole ty') t' a+    descendM f (Pi (x ::: ty) t a) = do+      ty' <- f ty+      t' <- f t+      return $ Pi (x ::: ty') t' a+    descendM f (Pi (Hole ty) t a) = do+      ty' <- f ty+      t' <- f t+      return $ Pi (Hole ty') t' a+    descendM f (App t1 t2 a) = do+      return App `ap` f t1 `ap` f t2 `ap` return a+    descendM f t = return t++-- | Pure bottom-up transformation on terms.+transform :: Transform t => (Expr (Id t) (A t) -> Expr (Id t) (A t)) -> t -> t+transform f = runIdentity . transformM (return . f)++descend :: Transform t => (Expr (Id t) (A t) -> Expr (Id t) (A t)) -> t -> t+descend f = runIdentity . descendM (return . f)++-- | Produces all substructures of the given term. Often useful as a generator+-- in a list comprehension.+everyone :: Transform t => t -> [Expr (Id t) (A t)]+everyone t = execState (transformM f t) [] where+    f t = withState (t:) (return t)
+ Dedukti/DkM.hs view
@@ -0,0 +1,81 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- The dedukti monad. This provides various facilities such as accumulating+-- warning messages or displaying error messages to the screen. Debugging+-- facilities and an interface to the system are also provided.++module Dedukti.DkM ( module Control.Monad+                  , DkM, runDkM, warn, warnings, say+                  , Verbosity(..)+                  , configuration, parameter+                  , command+                  -- pretty-printing combinators.+                  , Pretty(..), text, (<+>), (<>), int+                  , fillText+                  , E.Exception(..), Typeable, E.throw, io+                  , onException) where++import Dedukti.Config as Config+import Control.Monad+import Control.Monad.Reader+import qualified Control.Exception as E+import Control.Applicative+import Data.Typeable (Typeable) -- for exceptions+import System.IO+import System.Cmd+import System.Exit+import Text.PrettyPrint.Leijen hiding ((<$>))+++instance Applicative (ReaderT Config IO) where+    pure = return+    (<*>) = ap++newtype DkM a = DkM (ReaderT Config IO a)+    deriving (Monad, MonadIO, Functor, Applicative, MonadReader Config)++runDkM :: Config -> DkM a -> IO a+runDkM conf (DkM m) = runReaderT m conf++-- | Get all global parameters.+configuration :: DkM Config+configuration = ask++-- | Select one parameter.+parameter :: (Config -> a) -> DkM a+parameter sel = sel <$> ask++-- | Wrapper around 'rawSystem'.+command :: String -> [String] -> DkM ExitCode+command exe args = do+  say Verbose $ text "**" <+> text exe <+> hsep (map (squotes . text) args)+  io $ rawSystem exe args++-- | A pretty-printing combinator that outputs filled text with wrapping on+-- word boundaries.+fillText :: String -> Doc+fillText = fillSep . map text . words++-- | Register a new warning.+warn :: String -> DkM ()+warn = undefined++-- | Get the list of warnings so far.+warnings :: DkM [Doc]+warnings = undefined++-- | Write message only if verbosity level is at least the given level.+say :: Verbosity -> Doc -> DkM ()+say v msg = do v' <- parameter Config.verbosity+               when (v <= v') $ io $ hPutDoc stderr (msg <> line)++-- | Shorter name for the oft used 'liftIO'.+io :: IO a -> DkM a+io = liftIO++onException :: DkM a -> DkM b -> DkM a+onException x y = do+  conf <- configuration+  io $ runDkM conf x `E.onException` runDkM conf y
+ Dedukti/Driver/Batch.hs view
@@ -0,0 +1,115 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- The batch driver. It compiles all given targets and all their dependencies,+-- also invoking the Haskell compiler on the generated source code.+module Dedukti.Driver.Batch (make) where++import Dedukti.Driver.Compile+import Dedukti.Analysis.Dependency+import Dedukti.Module+import Dedukti.Parser+import Dedukti.DkM+import qualified Dedukti.Config as Config+import qualified Control.Hmk.IO as IO+import Control.Hmk+import qualified Data.Text.Lazy.Encoding as T+import qualified Data.ByteString.Lazy as B+import qualified Data.Map as Map+import Control.Monad.State+import Control.Applicative+import Data.Typeable (Typeable)+import System.Directory (copyFile)+import Data.Char (toUpper)+++cmp x y = do+  s <- io $ IO.isStale x y+  say Debug $ text "Compared" <+> text x <+> text y <> text ":" <+> text (show s)+  return s++-- | Trace a dependency graph in the form of a set of rules, starting from the+-- given root modules. Finding the dependencies of a module requires parsing+-- the corresponding source file. To avoid parsing each file twice, the AST is+-- kept in-memory in case it is needed later during compilation.+rules :: [MName] -> DkM [Rule DkM FilePath]+rules targets = evalStateT (rules' targets) Map.empty++-- Maintain a list of already seen modules to avoid parsing same modules twice+-- when the dependency graph is not a tree.+rules' targets = concat <$> mapM f targets where+    -- Collect dependencies.+    f mod = do+      seen <- get+      case Map.lookup mod seen of+        Just deps -> return deps+        Nothing -> do+          lift $ say Verbose $ text "Parsing" <+> text (show mod) <+> text "..."+          let path = srcPathFromModule mod+          src <- lift (parse path <$> io (liftM T.decodeUtf8 (B.readFile path)))+          let dependencies = collectDependencies src+              rs = g mod dependencies (task_compile mod src)+          -- Recursively construct rules for dependent modules.+          rsdeps <- rules' dependencies+          lift $ say Verbose $ text "Dependencies of" <+> text (show mod) <+> text ":"+                   <+> text (show dependencies)+          put (Map.insert mod (rs ++ rsdeps) seen)+          return $ rs ++ rsdeps+    -- Now that we have the dependencies of the module, we can enounce a few+    -- build rules concerning the module.+    g mod ds compile = let capitalize x = toUpper (head x) : tail x+                           eu  = srcPathFromModule mod+                           euo = objPathFromModule mod+                           eui = ifacePathFromModule mod+                           hi  = pathFromModule ".hi" mod+                           chi = capitalize hi+                           o   = pathFromModule ".o" mod+                           dephis = map (capitalize . pathFromModule ".hi") ds+                       in [ Rule eu [] Nothing cmp+                          , Rule euo [eu] (Just compile) cmp+                          , Rule eui [eu] (Just compile) cmp+                          , Rule hi (euo:eui:dephis) (Just $ task_hscomp euo) cmp+                          , Rule o (euo:eui:dephis) (Just $ task_hscomp euo) cmp+                          , Rule chi [hi] (Just $ task_himv hi chi) cmp ]+    task_hscomp euo _ = do+      hscomp <- parameter Config.hsCompiler+      io . IO.testExitCode =<< command hscomp [ "-c", "-w", "-x", "hs", euo+                                              , "-XOverloadedStrings"+                                              , "-XPatternGuards" ]+    -- GHC won't find the interface files if their names don't start with a+    -- capital letter. So alias the interface file with a capitalized name.+    task_himv hi chi _ = do+      io $ copyFile hi chi+      return TaskSuccess+    task_compile mod src _ = do+      compileAST mod src `onException`+          (say Quiet $ text "In module" <+> pretty mod <> text ":")+      return TaskSuccess++data CommandError = CommandError+    deriving Typeable++instance Show CommandError where+    show CommandError = "Command returned non-zero exit status."++instance Exception CommandError++-- | Perform each system action, aborting if an action returns+-- non-zero exit code.+abortOnError :: [DkM Result] -> DkM ()+abortOnError = mapM_ f where+    f cmd = do code <- cmd+               case code of+                 TaskSuccess -> return ()+                 TaskFailure -> throw CommandError++-- | Compile each of the modules given as input and all of their+-- dependencies, if necessary.+make :: [MName] -> DkM ()+make modules = do+  let targets = map (pathFromModule ".o") modules+  rs <- process cmp <$> rules modules+  schedule <- mk rs targets+  say Debug $ text "Tasks to execute:" <+> int (length schedule)+  abortOnError schedule
+ Dedukti/Driver/Compile.hs view
@@ -0,0 +1,80 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Compile one file to Haskell source code.++module Dedukti.Driver.Compile (compile, compileAST) where++import Dedukti.Module+import Dedukti.Parser+import Dedukti.DkM+import Dedukti.Core+import Dedukti.Analysis.Dependency+import Dedukti.Analysis.Scope+import qualified Dedukti.CodeGen.Exts as CG+import qualified Dedukti.Rule as Rule+import qualified Dedukti.Analysis.Rule as Rule+import qualified Data.Text.Lazy as T+import qualified Data.Text.Lazy.Encoding as T+import qualified Data.ByteString.Lazy as B+import qualified Data.Set as Set+++readT = io . liftM T.decodeUtf8 . B.readFile+writeT path = io . B.writeFile path . T.encodeUtf8++-- | Qualify all occurrences of identifiers defined in current module.+selfQualify :: MName -> [Pa RuleSet] -> [Pa RuleSet]+selfQualify mod rsets = let defs = Set.fromList (map rs_name rsets)+                        in map (descend (f defs))+                               (map (\RS{..} -> RS{rs_name = rs_name{qid_qualifier = mod}, ..}) rsets)+    where f defs (Var x a) | Nothing <- provenance x+                           , x `Set.member` defs = Var x{qid_qualifier = mod} a+          f defs (Lam (x ::: ty) t a) =+              Lam (x ::: f defs ty) (f (Set.delete x defs) t) a+          f defs (Pi (x ::: ty) t a) =+              Pi (x ::: f defs ty) (f (Set.delete x defs) t) a+          f defs t = descend (f defs) (t :: Pa Expr)++-- | Read the interface file of each module name to collect the declarations+-- exported by the module.+populateInitialEnvironment :: [MName] -> DkM (Set.Set Qid)+populateInitialEnvironment =+    liftM Set.unions .+    mapM (\dep -> let path = ifacePathFromModule dep+                  in liftM (Set.fromList . map (qual dep) . parseIface path) $+                     readT path)+        where qual mod qid = qid{qid_qualifier = mod}++-- | Generate the content of an interface file.+interface :: Pa Module -> T.Text+interface (decls, _) = T.unlines (map (qid_stem . bind_name) decls)++-- | Emit Haskell code for one module.+compile :: MName -> DkM ()+compile mod = do+  say Verbose $ text "Parsing" <+> text (show mod) <+> text "..."+  let path = srcPathFromModule mod+  compileAST mod =<< return (parse path) `ap` readT path++-- | Emit Haskell code for one module, starting from the AST.+compileAST :: MName -> Pa Module -> DkM ()+compileAST mod src@(decls, rules) = do+  let deps = collectDependencies src+  -- For the purposes of scope checking it is necessary to load in the+  -- environment all those declarations from immediate dependencies. For this+  -- we read an interface file, much faster to parse than the actual+  -- dependencies themselves.+  say Verbose $ text "Populating environment for" <+> text (show mod) <+> text "..."+  extdecls <- populateInitialEnvironment deps+  say Verbose $ text "Checking" <+> text (show mod) <+> text "..."+  checkUniqueness src+  checkScopes extdecls src+  Rule.checkOrdering rules+  mapM_ Rule.checkHead rules+  say Debug $ pretty (concatMap rs_rules (Rule.ruleSets decls rules))+  say Verbose $ text "Compiling" <+> text (show mod) <+> text "..."+  let code = map CG.emit (selfQualify mod (Rule.ruleSets decls rules)) :: [CG.Code]+  writeT (objPathFromModule mod) $ CG.serialize mod deps $ CG.coalesce code+  writeT (ifacePathFromModule mod) $ interface src
+ Dedukti/Driver/Interactive.hs view
@@ -0,0 +1,20 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL++module Dedukti.Driver.Interactive (eval) where++import Dedukti.Module+import Dedukti.Parser+import qualified Dedukti.CodeGen.Exts as CG+import qualified Dedukti.Rule as Rule+import Data.ByteString.Lazy (ByteString)+++-- | Emit Haskell code for one module.+eval :: String -> ByteString+eval input =+    let (decls, rules) = parse "<interactive>" input+        code = map CG.emit (Rule.ruleSets decls rules) :: [CG.Code]+        mod = Module (hierarchy ["interactive"])+    in CG.serialize (undefined :: CG.Code) mod $ CG.coalesce code
+ Dedukti/Module.hs view
@@ -0,0 +1,98 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- A representation of module names and associated functions to map module+-- names to source files and vice-versa. Qualified names, as required in the+-- presence of modules, are also defined here.+module Dedukti.Module+    ( -- * Data types+      Hierarchy(..), MName+    -- * Exceptions+    , InvalidModuleName(..)+    -- * Functions+    , hierarchy, toList+    , pathFromModule, moduleFromPath+    , srcPathFromModule, objPathFromModule, ifacePathFromModule+    -- * Qualified names.+    , Qid(..), qid, (.$), provenance, unqualify+    ) where++import Dedukti.DkM+import System.FilePath+import Data.Char (isAlpha, isAlphaNum)+import qualified Data.Text.Lazy as T+import Text.PrettyPrint.Leijen+++data Hierarchy = !Hierarchy :. !T.Text | Root+                 deriving (Eq, Ord, Show)++type MName = Hierarchy++newtype InvalidModuleName = InvalidModuleName String+    deriving (Eq, Ord, Typeable)++instance Show InvalidModuleName where+    show (InvalidModuleName name) = "invalid character in " ++ name++instance Exception InvalidModuleName++instance Pretty MName where+    pretty (Root :. x) = text (T.unpack x)+    pretty (xs :. x) = pretty xs <> char '.' <> text (T.unpack x)++hierarchy :: [T.Text] -> Hierarchy+hierarchy =  f . reverse where+    f [] = Root+    f (x:xs) = f xs :. x++toList :: Hierarchy -> [T.Text]+toList = reverse . f where+    f Root = []+    f (xs :. x) = x : f xs++-- | Raise an exception if module name component is a valid identifier.+check :: String -> String+check cmpt@(x:xs) | isAlpha x, and (map isAlphaNum xs) = cmpt+                  | otherwise = throw $ InvalidModuleName cmpt++pathFromModule :: String -> MName -> FilePath+pathFromModule ext mod =+    addExtension (joinPath $ map T.unpack $ toList mod) ext++moduleFromPath :: FilePath -> MName+moduleFromPath =+    hierarchy . map (T.pack . check) . splitDirectories . dropExtension++srcPathFromModule :: MName -> FilePath+srcPathFromModule = pathFromModule ".eu"++objPathFromModule :: MName -> FilePath+objPathFromModule = pathFromModule ".euo"++ifacePathFromModule :: MName -> FilePath+ifacePathFromModule = pathFromModule ".eui"++-- | The datatype of qualified names.+data Qid = Qid { qid_qualifier :: !Hierarchy+               , qid_stem      :: !T.Text+               , qid_suffix    :: !Hierarchy }+           deriving (Eq, Ord, Show)++-- | Shorthand qid introduction.+qid :: T.Text -> Qid+qid x = Qid Root x Root++-- | Append suffix.+(.$) :: Qid -> T.Text -> Qid+(Qid qual x sufs) .$ suf = Qid qual x (sufs :. suf)++-- | Get the module where the qid is defined, based on its qualifier.+provenance :: Qid -> Maybe MName+provenance (Qid Root _ _) = Nothing+provenance (Qid qual _ _) = Just qual++-- | Remove any qualifier.+unqualify :: Qid -> Qid+unqualify qid = qid{qid_qualifier = Root}
+ Dedukti/Parser.hs view
@@ -0,0 +1,181 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL++{-# OPTIONS_GHC -fno-warn-unused-binds #-}+module Dedukti.Parser (Pa, Dedukti.Parser.parse, parseIface) where++import Dedukti.Core+import Dedukti.Module+import Text.Parsec hiding (ParseError, parse)+import qualified Text.Parsec.Token as Token+import Control.Applicative hiding ((<|>), many)+import Control.Monad.Identity+import qualified Control.Exception as Exception+import qualified Data.Text.Lazy as T+import Data.Typeable (Typeable)+++-- The AST type as returned by the Parser.+type Pa t = t Qid Unannot++-- The parsing monad.+type P = Parsec String [Pa TyRule]++newtype ParseError = ParseError String+    deriving Typeable++instance Show ParseError where+    show (ParseError e) = e++instance Exception.Exception ParseError++newtype IfaceError = IfaceError String+    deriving Typeable++instance Show IfaceError where+    show (IfaceError f) = "Broken interface file " ++ f ++ "."++instance Exception.Exception IfaceError++parse :: SourceName -> T.Text -> Pa Module+parse name input =+    -- At the toplevel, a source file is a list of declarations and rule+    -- definitions. Here rules are accumulated by side-effect, added to the+    -- parser state as we encounter them.+    case runParser ((,) <$> toplevel <*> allRules) [] name (T.unpack input) of+      Left e -> Exception.throw (ParseError (show e))+      Right x -> x++-- | Parser for interface files.+parseIface :: SourceName -> T.Text -> [Qid]+parseIface _ = map qid . T.lines++addRule :: Pa TyRule -> P ()+addRule rule = modifyState (rule:)++-- | Retrieve all rules encountered so far from the parser state.+allRules :: P [Pa TyRule]+allRules = liftM reverse getState++lexDef = Token.LanguageDef+         { Token.commentStart = "(;"+         , Token.commentEnd = ";)"+         , Token.commentLine = ";"+         , Token.nestedComments = False+         , Token.identStart = alphaNum <|> char '_' <|> char '\''+         , Token.identLetter = alphaNum <|> char '_' <|> char '\''+         , Token.opStart = parserFail "No user defined operators yet."+         , Token.opLetter = parserFail "No user defined operators yet."+         , Token.reservedNames = ["Type", "Kind"]+         , Token.reservedOpNames = [":", "=>", "->", "-->"]+         , Token.caseSensitive = True+         }++Token.LanguageDef{..} = lexDef+Token.TokenParser{..} = Token.makeTokenParser lexDef++-- | Qualified or unqualified name.+--+-- > qid ::= id.id | id+qident = ident <?> "qid" where+    ident = do+      c <- identStart+      cs <- many identLetter+      x <- (do let qualifier = T.pack (c:cs)+               c <- try $ do char '.'; identStart+               cs <- many identLetter+               let name = T.pack (c:cs)+               return $ Qid (Root :. qualifier) name Root)+           <|> return (qid (T.pack (c:cs)))+      whiteSpace+      return (Var x nann)++-- | Unqualified name.+ident = qid . T.pack <$> identifier++-- | Root production rule of the grammar.+--+-- > toplevel ::= declaration toplevel+-- >            | rule toplevel+-- >            | eof+toplevel =+    whiteSpace *>+    (    (rule *> toplevel) -- Rules are accumulated by side-effect.+     <|> ((:) <$> declaration <*> toplevel)+     <|> (eof *> return []))++-- | Binding construct.+--+-- > binding ::= id : term+binding = ((:::) <$> ident <* reservedOp ":" <*> term)+          <?> "binding"++-- | Top-level declarations.+--+-- > declaration ::= id ":" term "."+declaration = (binding <* dot)+              <?> "declaration"++-- | Left hand side of an abstraction or a product.+--+-- > domain ::= id ":" applicative+-- >          | applicative+domain = (    ((:::) <$> try (ident <* reservedOp ":") <*> applicative)+          <|> (Hole <$> applicative))+         <?> "domain"++-- |+-- > sort ::= Type+sort = Type <$ reserved "Type"++-- | Terms and types.+--+-- We first try to parse as the domain of a lambda or pi. If we+-- later find out there was no arrow after the domain, then we take+-- the domain to be an expression, and return that.+--+-- > term ::= domain "->" term+-- >        | domain "=>" term+-- >        | applicative+term = do+  d <- domain+  choice [ pi d <?> "pi"+         , lambda d <?> "lambda"+         , return (bind_type d)]+    where pi d = Pi <$> pure d <* reservedOp "->" <*> term <%%> nann+          lambda d = Lam <$> pure d <* reservedOp "=>" <*> term <%%> nann++-- | Constituents of an applicative form.+--+-- > simple ::= sort+-- >          | qid+-- >          | "(" term ")"+simple = sort <|> qident <|> parens term++-- | Expressions that are either a name or an application of a+-- expression to one or more arguments.+--+-- > applicative ::= simple+-- >               | applicative simple+-- >+applicative = (\xs -> case xs of+                        [t] -> t+                        (f:ts) -> apply f ts (repeat nann))+              <$> many1 simple+              <?> "applicative"++-- | A rule.+--+-- > rule ::= env term "-->" term+-- > env ::= "[]"+-- >       | "[" env2 "]"+-- > env2 ::= binding+-- >        | binding "," env2+rule = ((\env lhs rhs -> foldr (&) emptyEnv env :@ lhs :--> rhs)+        <$> brackets (sepBy binding comma)+        <*> term+        <*  reservedOp "-->"+        <*> term+        <*  dot) >>= addRule+       <?> "rule"
+ Dedukti/Pretty.hs view
@@ -0,0 +1,58 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Pretty-printing of various core data types. This is not meant as a+-- replacement of the |Show| class but rather an alternative. You+-- should derive Show for all data types, then declare them instances+-- of |Pretty| where appropriate.++module Dedukti.Pretty (pretty) where++import Dedukti.Core+import Dedukti.Module+import Text.PrettyPrint.Leijen+import qualified Data.Text.Lazy as T+++textT = text . T.unpack++instance Pretty id => Pretty (Expr id a) where+    pretty (Lam x t _) = pretty x <+> text "=>" <+> pretty t+    pretty (Pi x t _) | Pi _ _ _ <- bind_type x = parens (pretty x) <+> text "->" <+> pretty t+                      | otherwise = pretty x <+> text "->" <+> pretty t+    pretty (App t1 t2 _) =+        let f = if isApplicative t1 then id else parens+            g = if isAtomic t2 then id else parens+        in f (pretty t1) <+> g (pretty t2)+    pretty (Var x _) = pretty x+    pretty Type = text "Type"+    pretty Kind = text "Kind"++instance Pretty id => Pretty (Binding id a) where+    pretty (x ::: ty) = pretty x <+> char ':' <+> pretty ty+    pretty (Hole ty) =  pretty ty++    prettyList = vcat . map (\x -> pretty x <> dot)++instance Pretty id => Pretty (Rule id a) where+    pretty (lhs :--> rhs) = pretty lhs <+> text "-->" <+> pretty rhs++instance (Eq a, Ord id, Pretty id) => Pretty (TyRule id a) where+    pretty (env :@ rule)+        | env == emptyEnv = text "[]" <+> pretty rule+        | otherwise =+            encloseSep (text "[ ") (text " ]") (text ", ")+                           (map pretty (env_bindings env))+            <+> pretty rule++    prettyList = vcat . map (\x -> pretty x <> dot)++instance Pretty Qid where+    pretty qid = joinQ (qid_qualifier qid) <>+                 textT (qid_stem qid) <>+                 joinS (qid_suffix qid)+        where joinQ Root = empty+              joinQ (h :. x) = joinQ h <> textT x <> dot+              joinS Root = empty+              joinS (h :. x) = joinS h <> char '_' <> textT x
+ Dedukti/Rule.hs view
@@ -0,0 +1,69 @@+-- |+-- Copyright : © 2009 CNRS - École Polytechnique - INRIA+-- License   : GPL+--+-- Various utility functions over rewrite rules and rule sets.++module Dedukti.Rule where++import Dedukti.Core+import Data.List (groupBy, sortBy)+import qualified Data.Stream as Stream+import Control.Monad.State+import qualified Data.Set as Set+import qualified Data.Map as Map+import Prelude hiding (head)+import qualified Prelude+++head :: TyRule id a -> Expr id a+head (_ :@ (lhs :--> _)) = lhs++headConstant :: TyRule id a -> id+headConstant = unvar . Prelude.head . unapply . head where+    unvar (Var x _) = x++patterns :: TyRule id a -> [Expr id a]+patterns = Prelude.tail . unapply . head++-- | Group set of rules by head constant.+group :: Eq id => [TyRule id a] -> [[TyRule id a]]+group = groupBy f where+    f x y = headConstant x == headConstant y++arity :: TyRule id a -> Int+arity (_ :@ lhs :--> _) = length (unapply lhs) - 1++-- | Combine declarations with their associated rules, if any.+ruleSets :: (Show id, Show a, Ord id) => [Binding id a] -> [TyRule id a] -> [RuleSet id a]+ruleSets ds rs = snd $ foldl aux (sortBy cmp (group rs), []) ds where+    aux ([],       rsets) (x ::: ty)          = ([], RS x ty [] : rsets)+    aux (rs : rss, rsets) (x ::: ty)+        | x == headConstant (Prelude.head rs) = (rss, RS x ty rs : rsets)+        | otherwise                           = (rs : rss, RS x ty [] : rsets)+    -- We cannot change the order of the declarations, but we need rules to be+    -- in the same order as the declarations.+    ordering = Map.fromList (zip (map bind_name ds) [0..])+    cmp x y = let xi = ordering Map.! headConstant (Prelude.head x)+                  yi = ordering Map.! headConstant (Prelude.head y)+              in compare xi yi++-- | Make the rule left-linear and return collected unification constraints.+-- This function must be provided with an infinite supply of fresh variable+-- names.+linearize :: Ord id => Stream.Stream id -> TyRule id a -> (TyRule id a, [(id, id)])+linearize xs (env :@ lhs :--> rhs) =+    let (lhs', (_, _, constraints)) = runState (transformM f lhs) (xs, Set.empty, [])+        -- Add new variables to the environment, with same type as+        -- that of the variables they are unified to.+        env' = foldr (\(x,x') env -> x' ::: (env ! x) & env) env constraints+    in (env' :@ lhs' :--> rhs, constraints)+    where f t@(Var x a) | x `isin` env = do+            (xs, seen, constraints) <- get+            if x `Set.member` seen then+                do let Stream.Cons x' xs' = xs+                   put (xs', Set.insert x seen, (x, x'):constraints)+                   return $ Var x' a else+                do put (xs, Set.insert x seen, constraints)+                   return t+          f t = return t
+ Dedukti/Runtime.hs view
@@ -0,0 +1,139 @@+-- Copyright © 2009 CNRS - École Polytechnique - INRIA+--+-- Permission to use, copy, modify, and distribute this file for any+-- purpose with or without fee is hereby granted, provided that the above+-- copyright notice and this permission notice appear in all copies.+--+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.++-- | All generated Haskell files import this module. The data type+-- declarations are given here, along with the conversion relation and type+-- inference function.++module Dedukti.Runtime+    ( Code(..), Term(..), ap+    , convertible+    , bbox, sbox, obj+    , start, stop+    , checkDeclaration+    , checkRule) where++import qualified Data.ByteString.Char8 as B+import Control.Exception+import Text.Show.Functions ()+import Data.Typeable hiding (typeOf)+import Prelude hiding (pi, catch)+import System.IO+import Data.Time.Clock+++-- Exceptions++data SortError = SortError+    deriving (Show, Typeable)++data TypeError = TypeError+    deriving (Show, Typeable)++data RuleError = RuleError+    deriving (Show, Typeable)++instance Exception SortError+instance Exception TypeError+instance Exception RuleError++-- Convertible and static terms.++data Code = Var !Int+          | Con !B.ByteString+          | Lam !(Code -> Code)+          | Pi  Code !(Code -> Code)+          | App Code Code+          | Type+          | Kind+            deriving (Eq, Show)++data Term = TLam !Term !(Term -> Term)+          | TPi  !Term !(Term -> Term)+          | TApp !Term !Term+          | TType+          | Box Code Code+          | UBox Term Code+            deriving Show++instance Eq (Code -> Code)++ap :: Code -> Code -> Code+ap (Lam f) t = f t+ap t1 t2 = App t1 t2++obj :: Term -> Code+obj (Box _ obj) = obj++convertible :: Int -> Code -> Code -> Bool+convertible n (Var x) (Var x') = x == x'+convertible n (Con c) (Con c') = c == c'+convertible n (Lam t) (Lam t') =+    convertible (n + 1) (t (Var n)) (t' (Var n))+convertible n (Pi ty1 ty2) (Pi ty3 ty4) =+    convertible n ty1 ty3 && convertible (n + 1) (ty2 (Var n)) (ty4 (Var n))+convertible n (App t1 t2) (App t3 t4) =+    convertible n t1 t3 && convertible n t2 t4+convertible n Type Type = True+convertible n Kind Kind = True+convertible n _ _ = False++-- | A box in which we didn't put anything.+emptyBox = Box undefined undefined++bbox, sbox :: Term -> Code -> Code -> Term++-- | A big box holds terms of sort Type or Kind+bbox = box [Type, Kind]++-- | A small box holds terms of sort Type.+sbox = box [Type]++box sorts ty ty_code obj_code+    | typeOf 0 ty `elem` sorts = Box ty_code obj_code+    | otherwise = throw SortError++typeOf :: Int -> Term -> Code+typeOf n (Box ty _) = ty+typeOf n (TLam bx@(Box Type a) f) = Pi a (\x -> typeOf n (f (Box a x)))+typeOf n (TPi bx@(Box Type a) f) = typeOf (n + 1) (f (Box a (Var n)))+typeOf n (TApp t1 bx@(Box ty2 t2))+    | Pi tya f <- typeOf n t1, convertible n tya ty2 = f t2+typeOf n (TApp t1 bx@(UBox tty2 t2))+    | Pi tya f <- typeOf n t1, ty2 <- typeOf n tty2,+      convertible n tya ty2 = f t2+typeOf n TType = Kind+typeOf n t = throw TypeError++checkDeclaration :: String -> Term -> IO ()+checkDeclaration x t = catch (evaluate t >> putStrLn "Check") handler+    where handler (SomeException e) = do+            putStrLn $ "Error during checking of " ++ x+            throw e++checkRule :: Term -> Term -> Term+checkRule lhs rhs | convertible 0 (typeOf 0 lhs) (typeOf 0 rhs) = emptyBox+                  | otherwise = throw RuleError++start :: IO UTCTime+start = do+  putStrLn "Start."+  getCurrentTime+++stop :: UTCTime -> IO ()+stop t = do+  t' <- getCurrentTime+  let total = diffUTCTime t' t+  putStrLn $ "Stop. Runtime: " ++ show total
+ Setup.lhs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+> import Distribution.Simple+> main = defaultMain
+ dedukti.cabal view
@@ -0,0 +1,58 @@+name:           dedukti+version:        1.0.0+author:         Mathieu Boespflug+maintainer:     Mathieu Boespflug <mboes@lix.polytechnique.fr>+copyright:      © 2009 CNRS - École Polytechnique - INRIA+homepage:       http://www.lix.polytechnique.fr/~mboes/src/dedukti.git+synopsis:       A type-checker for the λΠ-modulo calculus.+description:+    Dedukti is a proof checker for the λΠ-modulo calculus, a+    dependently typed λ-calculus with the addition of typed rewrite+    rules, capable of expressing proofs in Deduction Modulo [1].+    .+    [1] G. Dowek, Th. Hardin, C. Kirchner, Theorem proving modulo,+    /Journal of Automated Reasoning/, 31, 2003, pp. 33-72.+category:       Theorem Provers, Compilers/Interpreters+license:        GPL+license-file:   COPYING+cabal-version:  >= 1.6.0+build-type:     Simple+tested-with:    GHC ==6.10+data-files:     t/*.eu+++executable dedukti+  main-is:             Dedukti.hs+  other-modules:       Dedukti.Core,+                       Dedukti.Parser,+                       Dedukti.Pretty,+                       Dedukti.Driver.Interactive,+                       Dedukti.Driver.Batch,+                       Dedukti.Driver.Compile,+                       Dedukti.Rule,+                       Dedukti.DkM,+                       Dedukti.Config,+                       Dedukti.Module,+                       Dedukti.CodeGen+                       Dedukti.CodeGen.Exts,+                       Dedukti.Analysis.Rule,+                       Dedukti.Analysis.Scope,+                       Dedukti.Analysis.Dependency++  build-depends:       base >= 4 && < 5, mtl >= 1.1, containers >= 0.2,+                       directory, filepath, process,+                       parsec >= 3.0.0, wl-pprint >= 1.0, bytestring >= 0.9.1.0,+                       haskell-src-exts >= 1.1.0, Stream >= 0.3, text >= 0.3,+                       hmk >= 0.9+  extensions:          EmptyDataDecls, PatternGuards, GeneralizedNewtypeDeriving+                       DeriveDataTypeable, TypeFamilies, LiberalTypeSynonyms,+                       FlexibleInstances, FlexibleContexts, OverloadedStrings,+                       RecordWildCards, TypeSynonymInstances, ScopedTypeVariables+                       MultiParamTypeClasses+  ghc-options:         -fwarn-unused-binds -fwarn-unused-imports++library+  exposed-modules:     Dedukti.Runtime+  build-depends:       time >= 1.1+  extensions:          DeriveDataTypeable, PatternGuards, FlexibleInstances+  ghc-options:         -fwarn-unused-binds -fwarn-unused-imports
+ t/Coq1univ.eu view
@@ -0,0 +1,70 @@+Uset : Type.+Uprop : Type.+Utype : Type.++eprop : x : Uprop -> Type.+eset : x : Uset -> Type.+etype : x : Utype -> Type.++dotset : Utype.+dotprop : Utype.++; /!\ type : type /!\, should use universes+dottype : Utype.++; /!\ subtyping in coq, should be unidirectional /!\+[] Uprop --> Utype.+[] Uset --> Utype.++dotpipp : x : Uprop -> y : (eprop x -> Uprop) -> Uprop.+dotpips : x : Uprop -> y : (eprop x -> Uset)  -> Uset.+dotpipt : x : Uprop -> y : (eprop x -> Utype) -> Utype.+dotpisp : x : Uset  -> y : (eset x  -> Uprop) -> Uprop.+dotpitp : x : Utype -> y : (etype x -> Uprop) -> Uprop.+dotpist : x : Uset  -> y : (eset  x -> Utype) -> Utype.+dotpits : x : Utype -> y : (etype x -> Uset)  -> Uset.+dotpiss : x : Uset  -> y : (eset x  -> Uset)  -> Uset.+dotpitt : x : Utype -> y : (etype x -> Utype) -> Utype.+++[x:Uprop, y : eprop x -> Uprop]+              eprop (dotpipp x y) --> w : eprop x -> eprop (y w).++[x:Uset, y : eset x -> Uprop]+              eprop (dotpisp x y) --> w : eset x -> eprop (y w).++[x:Utype, y : etype x -> Uprop]+              eprop (dotpitp x y) --> w : etype x -> eprop (y w).++; /!\+[P : Uprop] eprop P --> etype P.++[x:Uprop, y : eprop x -> Uset]+              eset (dotpips x y) --> w : eprop x -> eset (y w).++[x:Utype, y : etype x -> Uset]+              eset (dotpits x y) --> w : etype x -> eset (y w).++[x:Uset, y : eset x -> Uset]+              eset (dotpiss x y) --> w : eset x -> eset (y w).++; /!\+[P : Uset] eset P --> etype P.++[x:Uset, y : eset x -> Utype]+              etype (dotpist x y) --> w : eset x -> etype (y w).++[x:Utype, y : etype x -> Utype]+              etype (dotpitt x y) --> w : etype x -> etype (y w).++[x:Uprop, y : eprop x -> Utype]+              etype (dotpipt x y) --> w : eprop x -> etype (y w).+++[] (etype dotset)  --> Uset.+[] (etype dotprop) --> Uprop.+; /!\+[] (etype dottype) --> Utype.++; end of Coq1univ+
+ t/Logic.eu view
@@ -0,0 +1,290 @@+True : Uprop.+I :  (eprop True) .+case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (_0 :  (eprop True)  ->  (etype P) ) ) ) ) .+I_case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (eprop True) ) ) ) .+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( (I_case_0 P)  f)  t)  --> I.+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( ( (case_0 P)  f)  t)   ( ( (I_case_0 P)  f)  t) )  --> f.+True_rect :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (etype P) ) ) ) .+[] True_rect -->  (P :  (etype dottype)  =>  (f :  (etype P)  =>  (t :  (eprop True)  =>  ( ( ( (case_0 P)  f)  t)  t) ) ) ) .+True_ind :  (P : Uprop ->  (f :  (eprop P)  ->  (t :  (eprop True)  ->  (eprop P) ) ) ) .+[] True_ind -->  (P :  (etype dotprop)  =>  (True_rect P) ) .+True_rec :  (P : Uset ->  (f :  (eset P)  ->  (t :  (eprop True)  ->  (eset P) ) ) ) .+[] True_rec -->  (P :  (etype dotset)  =>  (True_rect P) ) .+False : Uprop.+case_1 :  (P : Utype ->  (f :  (eprop False)  ->  (_1 :  (eprop False)  ->  (etype P) ) ) ) .+False_rect :  (P : Utype ->  (f :  (eprop False)  ->  (etype P) ) ) .+[] False_rect -->  (P :  (etype dottype)  =>  (f :  (eprop False)  =>  ( ( (case_1 P)  f)  f) ) ) .+False_ind :  (P : Uprop ->  (f :  (eprop False)  ->  (eprop P) ) ) .+[] False_ind -->  (P :  (etype dotprop)  =>  (False_rect P) ) .+False_rec :  (P : Uset ->  (f :  (eprop False)  ->  (eset P) ) ) .+[] False_rec -->  (P :  (etype dotset)  =>  (False_rect P) ) .+not :  (A : Uprop -> Uprop) .+[] not -->  (A :  (etype dotprop)  =>  ( (dotpipp A)   (_2 :  (eprop A)  => False) ) ) .+and :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+conj :  (A : Uprop ->  (B : Uprop ->  (_4 :  (eprop A)  ->  (_3 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) .+case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_6 :  (eprop A)  ->  (_5 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_7 :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) ) .+conj_case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_11 :  (eprop A)  ->  (_10 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_13 :  (eprop A)  ->  (_12 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Utype, f :  (_15 :  (eprop A)  ->  (_14 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) ]  ( ( ( ( (conj_case_2 A)  B)  P)  f)  a)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, P : Utype, f :  (_9 :  (eprop A)  ->  (_8 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) , var_0 :  (eprop A) , var_1 :  (eprop B) ]  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)   ( ( ( ( ( ( (conj_case_2 A)  B)  P)  f)  a)  var_0)  var_1) )  -->  ( (f var_0)  var_1) .+and_rect :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_19 :  (eprop A)  ->  (_18 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) .+[] and_rect -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dottype)  =>  (f :  (etype  ( (dotpipt A)   (_17 :  (eprop A)  =>  ( (dotpipt B)   (_16 :  (eprop B)  => P) ) ) ) )  =>  (a :  (eprop  ( (and A)  B) )  =>  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)  a) ) ) ) ) ) .+and_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_21 :  (eprop A)  ->  (_20 :  (eprop B)  ->  (eprop P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eprop P) ) ) ) ) ) .+[] and_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+and_rec :  (A : Uprop ->  (B : Uprop ->  (P : Uset ->  (f :  (_23 :  (eprop A)  ->  (_22 :  (eprop B)  ->  (eset P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eset P) ) ) ) ) ) .+[] and_rec -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotset)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_24 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) ) .+conj_case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_26 :  (eprop A)  ->  (_25 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) ]  ( ( (conj_case_3 A)  B)  H)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_2 :  (eprop A) , var_3 :  (eprop B) ]  ( ( ( (case_3 A)  B)  H)   ( ( ( ( (conj_case_3 A)  B)  H)  var_2)  var_3) )  -->  ( ( (H欧0 :  (eprop A)  =>  (H0 :  (eprop B)  => H欧0) )  var_2)  var_3) .+proj1 :  (A : Uprop ->  (B : Uprop ->  (_27 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) .+[] proj1 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_3 A)  B)  H)  H) ) ) ) .+case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_28 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) ) .+conj_case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_30 :  (eprop A)  ->  (_29 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) ]  ( ( (conj_case_4 A)  B)  H)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_4 :  (eprop A) , var_5 :  (eprop B) ]  ( ( ( (case_4 A)  B)  H)   ( ( ( ( (conj_case_4 A)  B)  H)  var_4)  var_5) )  -->  ( ( (H欧0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_4)  var_5) .+proj2 :  (A : Uprop ->  (B : Uprop ->  (_31 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) .+[] proj2 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_4 A)  B)  H)  H) ) ) ) .+or :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+or_introl :  (A : Uprop ->  (B : Uprop ->  (_32 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) .+or_intror :  (A : Uprop ->  (B : Uprop ->  (_33 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) .+case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_34 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_35 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_36 :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) ) .+or_introl_case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_39 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_40 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_41 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_42 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_43 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) ]  ( ( ( ( ( (or_introl_case_5 A)  B)  P)  f)  f欧0)  o)  -->  ( (or_introl A)  B) .+or_intror_case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_44 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_45 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_46 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_47 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_48 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) ]  ( ( ( ( ( (or_intror_case_5 A)  B)  P)  f)  f欧0)  o)  -->  ( (or_intror A)  B) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_37 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_38 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_6 :  (eprop A) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)   ( ( ( ( ( ( (or_introl_case_5 A)  B)  P)  f)  f欧0)  o)  var_6) )  -->  (f var_6) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_37 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_38 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_7 :  (eprop B) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)   ( ( ( ( ( ( (or_intror_case_5 A)  B)  P)  f)  f欧0)  o)  var_7) )  -->  (f欧0 var_7) .+or_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_51 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_52 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) .+[] or_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpipp A)   (_50 :  (eprop A)  => P) ) )  =>  (f欧0 :  (eprop  ( (dotpipp B)   (_49 :  (eprop B)  => P) ) )  =>  (o :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)  o) ) ) ) ) ) ) .+iff :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+[] iff -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( (and  ( (dotpipp A)   (_53 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_54 :  (eprop B)  => A) ) ) ) ) .+iff_refl :  (A : Uprop ->  (eprop  ( (iff A)  A) ) ) .+[] iff_refl -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp A)   (_55 :  (eprop A)  => A) ) )   ( (dotpipp A)   (_56 :  (eprop A)  => A) ) )   (H :  (eprop A)  => H) )   (H :  (eprop A)  => H) ) ) .+case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_60 :  (eprop  ( (and  ( (dotpipp A)   (_57 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_58 :  (eprop B)  => A) ) ) )  ->  (_59 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) .+conj_case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_68 :  (_63 :  (eprop A)  ->  (eprop B) )  ->  (_67 :  (_64 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_65 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_66 :  (eprop B)  => A) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( ( (conj_case_6 A)  B)  C)  H)  -->  ( (conj  ( (dotpipp A)   (_61 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_62 :  (eprop B)  => A) ) ) .+case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_71 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_72 :  (eprop B)  ->  (eprop A) )  ->  (H欧0 :  (eprop  ( (iff B)  C) )  ->  (_75 :  (eprop  ( (and  ( (dotpipp B)   (_73 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_74 :  (eprop C)  => B) ) ) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) ) ) .+conj_case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_80 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_81 :  (eprop B)  ->  (eprop A) )  ->  (H欧0 :  (eprop  ( (iff B)  C) )  ->  (_87 :  (_82 :  (eprop B)  ->  (eprop C) )  ->  (_86 :  (_83 :  (eprop C)  ->  (eprop B) )  ->  (eprop  ( (and  ( (dotpipp B)   (_84 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_85 :  (eprop C)  => B) ) ) ) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_88 :  (eprop A)  ->  (eprop B) ) , H2 :  (_89 :  (eprop B)  ->  (eprop A) ) , H欧0 :  (eprop  ( (iff B)  C) ) ]  ( ( ( ( ( ( (conj_case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  -->  ( (conj  ( (dotpipp B)   (_78 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_79 :  (eprop C)  => B) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_76 :  (eprop A)  ->  (eprop B) ) , H2 :  (_77 :  (eprop B)  ->  (eprop A) ) , H欧0 :  (eprop  ( (iff B)  C) ) , var_10 :  (_90 :  (eprop B)  ->  (eprop C) ) , var_11 :  (_91 :  (eprop C)  ->  (eprop B) ) ]  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H欧0)   ( ( ( ( ( ( ( ( (conj_case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  var_10)  var_11) )  -->  ( ( (H3 :  (eprop  ( (dotpipp B)   (_95 :  (eprop B)  => C) ) )  =>  (H4 :  (eprop  ( (dotpipp C)   (_94 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_92 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_93 :  (eprop C)  => A) ) )   (H欧1 :  (eprop A)  =>  (H3  (H1 H欧1) ) ) )   (H欧1 :  (eprop C)  =>  (H2  (H1  (H2  (H4 H欧1) ) ) ) ) ) ) )  var_10)  var_11) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , var_8 :  (_69 :  (eprop A)  ->  (eprop B) ) , var_9 :  (_70 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( ( (case_6 A)  B)  C)  H)   ( ( ( ( ( (conj_case_6 A)  B)  C)  H)  var_8)  var_9) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_97 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_96 :  (eprop B)  => A) ) )  =>  (H欧0 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  H欧0) ) ) )  var_8)  var_9) .+iff_trans :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_99 :  (eprop  ( (iff A)  B) )  ->  (_98 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) .+[] iff_trans -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (case_6 A)  B)  C)  H)  H) ) ) ) ) .+case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_102 :  (eprop  ( (and  ( (dotpipp A)   (_100 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_101 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (iff B)  A) ) ) ) ) ) .+conj_case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_110 :  (_105 :  (eprop A)  ->  (eprop B) )  ->  (_109 :  (_106 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_107 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_108 :  (eprop B)  => A) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( (conj_case_8 A)  B)  H)  -->  ( (conj  ( (dotpipp A)   (_103 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_104 :  (eprop B)  => A) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_12 :  (_111 :  (eprop A)  ->  (eprop B) ) , var_13 :  (_112 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( (case_8 A)  B)  H)   ( ( ( ( (conj_case_8 A)  B)  H)  var_12)  var_13) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_116 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_115 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_113 :  (eprop B)  => A) ) )   ( (dotpipp A)   (_114 :  (eprop A)  => B) ) )  H2)  H1) ) )  var_12)  var_13) .+iff_sym :  (A : Uprop ->  (B : Uprop ->  (_117 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (iff B)  A) ) ) ) ) .+[] iff_sym -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_8 A)  B)  H)  H) ) ) ) .+case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_128 :  (eprop  ( (and  ( (dotpipp A)   (_125 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_126 :  (eprop False)  => A) ) ) )  ->  (_127 :  (eprop A)  ->  (eprop False) ) ) ) ) .+conj_case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_136 :  (_131 :  (eprop A)  ->  (eprop False) )  ->  (_135 :  (_132 :  (eprop False)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_133 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_134 :  (eprop False)  => A) ) ) ) ) ) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) ]  ( (conj_case_9 A)  H)  -->  ( (conj  ( (dotpipp A)   (_129 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_130 :  (eprop False)  => A) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) , var_14 :  (_137 :  (eprop A)  ->  (eprop False) ) , var_15 :  (_138 :  (eprop False)  ->  (eprop A) ) ]  ( ( (case_9 A)  H)   ( ( ( (conj_case_9 A)  H)  var_14)  var_15) )  -->  ( ( (H欧0 :  (eprop  ( (dotpipp A)   (_140 :  (eprop A)  => False) ) )  =>  (H0 :  (eprop  ( (dotpipp False)   (_139 :  (eprop False)  => A) ) )  => H欧0) )  var_14)  var_15) .+neg_false :  (A : Uprop ->  (eprop  ( (iff  (not A) )   ( (iff A)  False) ) ) ) .+[] neg_false -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (dotpipp A)   (_118 :  (eprop A)  => False) ) )   (_119 :  (eprop  ( (dotpipp A)   (_118 :  (eprop A)  => False) ) )  =>  ( (iff A)  False) ) ) )   ( (dotpipp  ( (iff A)  False) )   (_121 :  (eprop  ( (iff A)  False) )  =>  ( (dotpipp A)   (_120 :  (eprop A)  => False) ) ) ) )   (H :  (eprop  ( (dotpipp A)   (_124 :  (eprop A)  => False) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_122 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_123 :  (eprop False)  => A) ) )  H)   (H1 :  (eprop False)  =>  ( (False_ind A)  H1) ) ) ) )   (H :  (eprop  ( (iff A)  False) )  =>  ( ( (case_9 A)  H)  H) ) ) ) .+and_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_168 :  (_165 :  (eprop B)  ->  (eprop A) )  ->  (_167 :  (_166 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_164 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_163 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (_141 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_142 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and A)  B) )   (_143 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_144 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and A)  B) )   (_156 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and A)  C) )   (_155 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp A)   (_154 :  (eprop A)  =>  ( (dotpipp B)   (_153 :  (eprop B)  =>  ( (and A)  C) ) ) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp A)   (_152 :  (eprop A)  =>  ( (dotpipp C)   (_151 :  (eprop C)  =>  ( (and A)  B) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_145 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_146 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp B)   (_148 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  C)   (H欧1 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H1欧2 :  (eprop  ( (dotpipp C)   (_147 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H2欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  C)   (H1欧3 :  (eprop A)  =>  (H6 :  (eprop B)  => H5) ) )  H0欧0) )   (H1欧2 H5) ) )   (H0 H5) ) )   (H2欧0 H4) ) ) ) )  H1欧1) )   (H欧0 H3欧0) ) )   (H1欧0 H4) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp B)   (_150 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H1欧1 :  (eprop  ( (dotpipp C)   (_149 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  B)   (H1欧2 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H2欧2 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  B)   (H0欧1 :  (eprop A)  =>  (H6 :  (eprop C)  => H5) ) )  H欧0) )   (H0欧0 H5) ) )   (H H5) ) ) ) )  H2欧1) )   (H1欧1 H3欧0) ) )   (H2欧0 H4) ) )   (H1欧0 H4) ) )   (H0 H3欧0) ) ) ) )   (H2欧0 :  (eprop A)  =>  (H4 :  (eprop C)  =>  (H3  ( ( ( (conj A)  C)  H2欧0)  H4) ) ) ) ) )   (H1欧0 :  (eprop A)  =>  (H4 :  (eprop B)  =>  (H2  ( ( ( (conj A)  B)  H1欧0)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_157 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_158 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_162 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_161 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_159 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_160 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H1欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H4 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2欧0)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H5) ) )   (H H5) ) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H4 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H3欧0)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H5) ) )   (H0 H5) ) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_196 :  (_193 :  (eprop B)  ->  (eprop A) )  ->  (_195 :  (_194 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_192 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_191 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (_169 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_170 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and B)  A) )   (_171 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_172 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and B)  A) )   (_184 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and C)  A) )   (_183 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp B)   (_182 :  (eprop B)  =>  ( (dotpipp A)   (_181 :  (eprop A)  =>  ( (and C)  A) ) ) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp C)   (_180 :  (eprop C)  =>  ( (dotpipp A)   (_179 :  (eprop A)  =>  ( (and B)  A) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_173 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_174 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp A)   (_176 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  C)   (H欧1 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H1欧2 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp A)   (_175 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  C)   (H0欧1 :  (eprop B)  =>  (H6 :  (eprop A)  => H欧1) ) )  H2欧1) )   (H0欧0 H4) ) )   (H2欧0 H欧1) ) )   (H0 H欧1) ) ) ) )  H1欧1) )   (H欧0 H4) ) )   (H1欧0 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp A)   (_178 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  B)   (H0欧1 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H2欧2 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp A)   (_177 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  B)   (H欧1 :  (eprop C)  =>  (H6 :  (eprop A)  => H0欧1) ) )  H1欧1) )   (H欧0 H4) ) )   (H1欧0 H0欧1) ) )   (H H0欧1) ) ) ) )  H2欧1) )   (H0欧0 H4) ) )   (H2欧0 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H2欧0 :  (eprop C)  =>  (H4 :  (eprop A)  =>  (H3  ( ( ( (conj C)  A)  H2欧0)  H4) ) ) ) ) )   (H1欧0 :  (eprop B)  =>  (H4 :  (eprop A)  =>  (H2  ( ( ( (conj B)  A)  H1欧0)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_185 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_186 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_190 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_189 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_187 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_188 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H1欧0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H4 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj C)  A)  H欧0)  H2欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H4 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H0欧0)  H3欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_220 :  (_217 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_219 :  (_218 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_216 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_215 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (_197 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_198 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or A)  B) )   (_199 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_200 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or A)  B) )   (_208 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or A)  C) )   (_207 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp A)   (_206 :  (eprop A)  =>  ( (or A)  C) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp B)   (_205 :  (eprop B)  =>  ( (or A)  C) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp A)   (_204 :  (eprop A)  =>  ( (or A)  B) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp C)   (_203 :  (eprop C)  =>  ( (or A)  B) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_201 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_202 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H4欧0 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H1欧1 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )   (H5欧0 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H5 H1欧1) ) )   (H6欧0 H4欧0) ) )   (H0 H1欧1) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )   (H5欧0 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H5 H1欧1) ) )   (H6欧0 H4欧0) ) )   (H0 H1欧1) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )  H欧1) )   (H1欧0 H4欧0) ) ) )   (H4欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H1欧1 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )  H0欧1) )   (H1欧0 H5欧0) ) ) )   (H5欧0 :  (eprop B)  => H4欧0) )  H0欧0) )   (H5 H4欧0) ) )   (H0 H4欧0) ) ) )  H欧0) )   (H4 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H5欧0 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H1欧1 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )   (H4欧0 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H4 H2欧1) ) )   (H6欧0 H5欧0) ) )   (H H2欧1) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )   (H4欧0 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H4 H2欧1) ) )   (H6欧0 H5欧0) ) )   (H H2欧1) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )  H0欧1) )   (H1欧0 H5欧0) ) ) )   (H5欧0 :  (eprop B)  =>  ( (H0欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H1欧1 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )  H欧1) )   (H1欧0 H4欧0) ) ) )   (H4欧0 :  (eprop C)  => H5欧0) )  H欧0) )   (H4 H5欧0) ) )   (H H5欧0) ) ) )  H0欧0) )   (H5 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H5 :  (eprop C)  =>  (H3  ( ( (or_intror A)  C)  H5) ) ) ) )   (H2欧0 :  (eprop A)  =>  (H3  ( ( (or_introl A)  C)  H2欧0) ) ) ) )   (H4 :  (eprop B)  =>  (H2  ( ( (or_intror A)  B)  H4) ) ) ) )   (H1欧0 :  (eprop A)  =>  (H2  ( ( (or_introl A)  B)  H1欧0) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_209 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_210 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_214 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_213 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_211 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_212 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H1欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  C)  H4) ) )   (H4 :  (eprop B)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_intror A)  C)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  B)  H4) ) )   (H4 :  (eprop C)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_244 :  (_241 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_243 :  (_242 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_240 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_239 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (_221 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_222 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or B)  A) )   (_223 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_224 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or B)  A) )   (_232 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or C)  A) )   (_231 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp B)   (_230 :  (eprop B)  =>  ( (or C)  A) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp A)   (_229 :  (eprop A)  =>  ( (or C)  A) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp C)   (_228 :  (eprop C)  =>  ( (or B)  A) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp A)   (_227 :  (eprop A)  =>  ( (or B)  A) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_225 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_226 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H1欧1 :  (eprop C)  =>  ( (H欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  => H1欧1) )   (H2欧1 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H4欧0 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )  H0欧1) )   (H4 H2欧1) ) ) )  H0欧0) )   (H2欧0 H1欧1) ) )   (H0 H1欧1) ) ) )   (H1欧1 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H4欧0 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )   (H2欧1 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H2欧0 H4欧0) ) )   (H6欧0 H1欧1) ) )   (H0 H4欧0) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )   (H2欧1 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H2欧0 H4欧0) ) )   (H6欧0 H1欧1) ) )   (H0 H4欧0) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )  H欧1) )   (H4 H1欧1) ) ) )  H欧0) )   (H1欧0 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H2欧1 :  (eprop B)  =>  ( (H0欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  => H2欧1) )   (H1欧1 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H4欧0 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )  H欧1) )   (H4 H1欧1) ) ) )  H欧0) )   (H1欧0 H2欧1) ) )   (H H2欧1) ) ) )   (H2欧1 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H4欧0 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )   (H1欧1 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H1欧0 H5欧0) ) )   (H6欧0 H2欧1) ) )   (H H5欧0) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )   (H1欧1 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H1欧0 H5欧0) ) )   (H6欧0 H2欧1) ) )   (H H5欧0) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )  H0欧1) )   (H4 H2欧1) ) ) )  H0欧0) )   (H2欧0 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H5 :  (eprop A)  =>  (H3  ( ( (or_intror C)  A)  H5) ) ) ) )   (H2欧0 :  (eprop C)  =>  (H3  ( ( (or_introl C)  A)  H2欧0) ) ) ) )   (H4 :  (eprop A)  =>  (H2  ( ( (or_intror B)  A)  H4) ) ) ) )   (H1欧0 :  (eprop B)  =>  (H2  ( ( (or_introl B)  A)  H1欧0) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_233 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_234 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_238 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_237 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_235 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_236 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H1欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H4 :  (eprop B)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_introl C)  A)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror C)  A)  H4) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H4 :  (eprop C)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror B)  A)  H4) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_251 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) ) ) ) .+[] and_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_245 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_246 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_250 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_249 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_247 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_248 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H2 :  (eprop A)  =>  (H3 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2)  H欧1) )   (H1 H欧1) ) )   (H0 H3) ) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H2 :  (eprop A)  =>  (H3 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H2)  H欧1) )   (H0 H欧1) ) )   (H1 H3) ) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+and_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_258 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) ) ) ) .+[] and_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_252 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_253 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_257 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_256 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_254 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_255 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H欧0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H2 :  (eprop B)  =>  (H3 :  (eprop A)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj C)  A)  H欧1)  H3) )   (H1 H欧1) ) )   (H0 H2) ) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H2 :  (eprop C)  =>  (H3 :  (eprop A)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H欧1)  H3) )   (H0 H欧1) ) )   (H1 H2) ) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_265 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) ) ) ) .+[] or_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_259 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_260 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_264 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_263 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_261 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_262 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  C)  H2) ) )   (H2 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_intror A)  C)  H欧1) )   (H1 H欧1) ) )   (H0 H2) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  B)  H2) ) )   (H2 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H欧1) )   (H0 H欧1) ) )   (H1 H2) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_272 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) ) ) ) .+[] or_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_266 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_267 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_271 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_270 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_268 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_269 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H2 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_introl C)  A)  H欧1) )   (H1 H欧1) ) )   (H0 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror C)  A)  H2) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H2 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H欧1) )   (H0 H欧1) ) )   (H1 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror B)  A)  H2) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_277 :  (eprop  ( (and  ( (dotpipp A)   (_273 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_274 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (and  ( (dotpipp A)   (_275 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_276 :  (eprop B)  => A) ) ) ) ) ) ) ) .+conj_case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_285 :  (_280 :  (eprop A)  ->  (eprop B) )  ->  (_284 :  (_281 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_282 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_283 :  (eprop B)  => A) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( (conj_case_10 A)  B)  H)  -->  ( (conj  ( (dotpipp A)   (_278 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_279 :  (eprop B)  => A) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_16 :  (_286 :  (eprop A)  ->  (eprop B) ) , var_17 :  (_287 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( (case_10 A)  B)  H)   ( ( ( ( (conj_case_10 A)  B)  H)  var_16)  var_17) )  -->  ( ( (H欧0 :  (eprop  ( (dotpipp A)   (_291 :  (eprop A)  => B) ) )  =>  (H0 :  (eprop  ( (dotpipp B)   (_290 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_288 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_289 :  (eprop B)  => A) ) )  H欧0)  H0) ) )  var_16)  var_17) .+iff_and :  (A : Uprop ->  (B : Uprop ->  (_294 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (and  ( (dotpipp A)   (_292 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_293 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_10 A)  B)  H)  H) ) ) ) .+iff_to_and :  (A : Uprop ->  (B : Uprop ->  (eprop  ( (iff  ( (iff A)  B) )   ( (and  ( (dotpipp A)   (_317 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_318 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_to_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (iff A)  B) )   (_297 :  (eprop  ( (iff A)  B) )  =>  ( (and  ( (dotpipp A)   (_295 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_296 :  (eprop B)  => A) ) ) ) ) )   ( (dotpipp  ( (and  ( (dotpipp A)   (_298 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_299 :  (eprop B)  => A) ) ) )   (_300 :  (eprop  ( (and  ( (dotpipp A)   (_298 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_299 :  (eprop B)  => A) ) ) )  =>  ( (iff A)  B) ) ) )   (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_301 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_302 :  (eprop B)  => A) ) )   ( (and  ( (dotpipp A)   (_303 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_304 :  (eprop B)  => A) ) ) )   (H0 :  (eprop  ( (dotpipp A)   (_308 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_307 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_305 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_306 :  (eprop B)  => A) ) )   (H欧0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H0欧0 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H欧0) ) ) )   (H欧0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H1欧0 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H欧0) ) ) ) ) ) )  H) ) )   (H :  (eprop  ( (and  ( (dotpipp A)   (_315 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_316 :  (eprop B)  => A) ) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_309 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_310 :  (eprop B)  => A) ) )   ( (iff A)  B) )   (H0 :  (eprop  ( (dotpipp A)   (_314 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_313 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_311 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_312 :  (eprop B)  => A) ) )   (H欧0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H0欧0 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H欧0) ) ) )   (H欧0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H1欧0 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H欧0) ) ) ) ) ) )  H) ) ) ) ) .+IF_then_else :  (P : Uprop ->  (Q : Uprop ->  (R : Uprop -> Uprop) ) ) .+[] IF_then_else -->  (P :  (etype dotprop)  =>  (Q :  (etype dotprop)  =>  (R :  (etype dotprop)  =>  ( (or  ( (and P)  Q) )   ( (and  (not P) )  R) ) ) ) ) .+ex :  (A : Utype ->  (P :  (_319 :  (etype A)  -> Uprop)  -> Uprop) ) .+ex_intro :  (A : Utype ->  (P :  (_320 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_321 :  (eprop  (P x) )  ->  (eprop  ( (ex A)  P) ) ) ) ) ) .+case_11 :  (A : Utype ->  (P :  (_322 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_323 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (_324 :  (eprop  ( (ex A)  P) )  ->  (eprop P欧0) ) ) ) ) ) ) .+ex_intro_case_11 :  (A : Utype ->  (P :  (_327 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_328 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (x :  (etype A)  ->  (_329 :  (eprop  (P x) )  ->  (eprop  ( (ex A)  P) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_330 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_331 :  (eprop  (P x) )  ->  (eprop P欧0) ) ) , e :  (eprop  ( (ex A)  P) ) ]  ( ( ( ( (ex_intro_case_11 A)  P)  P欧0)  f)  e)  -->  ( (ex_intro A)  P) .+[A : Utype, P :  (_325 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_326 :  (eprop  (P x) )  ->  (eprop P欧0) ) ) , e :  (eprop  ( (ex A)  P) ) , var_18 :  (etype A) , var_19 :  (eprop  (P var_18) ) ]  ( ( ( ( ( (case_11 A)  P)  P欧0)  f)  e)   ( ( ( ( ( ( (ex_intro_case_11 A)  P)  P欧0)  f)  e)  var_18)  var_19) )  -->  ( (f var_18)  var_19) .+ex_ind :  (A : Utype ->  (P :  (_334 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_335 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (eprop P欧0) ) ) ) ) ) .+[] ex_ind -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_333 :  (etype A)  => dotprop) ) )  =>  (P欧0 :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpipp  (P x) )   (_332 :  (eprop  (P x) )  => P欧0) ) ) ) )  =>  (e :  (eprop  ( (ex A)  P) )  =>  ( ( ( ( ( (case_11 A)  P)  P欧0)  f)  e)  e) ) ) ) ) ) .+ex2 :  (A : Utype ->  (P :  (_336 :  (etype A)  -> Uprop)  ->  (Q :  (_337 :  (etype A)  -> Uprop)  -> Uprop) ) ) .+ex_intro2 :  (A : Utype ->  (P :  (_338 :  (etype A)  -> Uprop)  ->  (Q :  (_339 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_341 :  (eprop  (P x) )  ->  (_340 :  (eprop  (Q x) )  ->  (eprop  ( ( (ex2 A)  P)  Q) ) ) ) ) ) ) ) .+case_12 :  (A : Utype ->  (P :  (_342 :  (etype A)  -> Uprop)  ->  (Q :  (_343 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_345 :  (eprop  (P x) )  ->  (_344 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (_346 :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (eprop P欧0) ) ) ) ) ) ) ) .+ex_intro2_case_12 :  (A : Utype ->  (P :  (_351 :  (etype A)  -> Uprop)  ->  (Q :  (_352 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_354 :  (eprop  (P x) )  ->  (_353 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (x :  (etype A)  ->  (_356 :  (eprop  (P x) )  ->  (_355 :  (eprop  (Q x) )  ->  (eprop  ( ( (ex2 A)  P)  Q) ) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_357 :  (etype A)  -> Uprop) , Q :  (_358 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_360 :  (eprop  (P x) )  ->  (_359 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) ) , e :  (eprop  ( ( (ex2 A)  P)  Q) ) ]  ( ( ( ( ( (ex_intro2_case_12 A)  P)  Q)  P欧0)  f)  e)  -->  ( ( (ex_intro2 A)  P)  Q) .+[A : Utype, P :  (_347 :  (etype A)  -> Uprop) , Q :  (_348 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_350 :  (eprop  (P x) )  ->  (_349 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) ) , e :  (eprop  ( ( (ex2 A)  P)  Q) ) , var_20 :  (etype A) , var_21 :  (eprop  (P var_20) ) , var_22 :  (eprop  (Q var_20) ) ]  ( ( ( ( ( ( (case_12 A)  P)  Q)  P欧0)  f)  e)   ( ( ( ( ( ( ( ( (ex_intro2_case_12 A)  P)  Q)  P欧0)  f)  e)  var_20)  var_21)  var_22) )  -->  ( ( (f var_20)  var_21)  var_22) .+ex2_ind :  (A : Utype ->  (P :  (_365 :  (etype A)  -> Uprop)  ->  (Q :  (_366 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_368 :  (eprop  (P x) )  ->  (_367 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (eprop P欧0) ) ) ) ) ) ) .+[] ex2_ind -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_364 :  (etype A)  => dotprop) ) )  =>  (Q :  (etype  ( (dotpitt A)   (_363 :  (etype A)  => dotprop) ) )  =>  (P欧0 :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpipp  (P x) )   (_362 :  (eprop  (P x) )  =>  ( (dotpipp  (Q x) )   (_361 :  (eprop  (Q x) )  => P欧0) ) ) ) ) ) )  =>  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  =>  ( ( ( ( ( ( (case_12 A)  P)  Q)  P欧0)  f)  e)  e) ) ) ) ) ) ) .+all :  (A : Utype ->  (P :  (_370 :  (etype A)  -> Uprop)  -> Uprop) ) .+[] all -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_369 :  (etype A)  => dotprop) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  (P x) ) ) ) ) .+inst :  (A : Utype ->  (P :  (_372 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_373 :  (eprop  ( (all A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  ->  (eprop  (P x) ) ) ) ) ) .+[] inst -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_371 :  (etype A)  => dotprop) ) )  =>  (x :  (etype A)  =>  (H :  (eprop  ( (dotpitp A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  =>  (H x) ) ) ) ) .+gen :  (A : Utype ->  (P :  (_376 :  (etype A)  -> Uprop)  ->  (B : Uprop ->  (f :  (y :  (etype A)  ->  (_377 :  (eprop B)  ->  (eprop  (P y) ) ) )  ->  (_378 :  (eprop B)  ->  (eprop  ( (all A)  P) ) ) ) ) ) ) .+[] gen -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_375 :  (etype A)  => dotprop) ) )  =>  (B :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (y :  (etype A)  =>  ( (dotpipp B)   (_374 :  (eprop B)  =>  (P y) ) ) ) ) )  =>  (H :  (eprop B)  =>  (x :  (etype A)  =>  ( (f x)  H) ) ) ) ) ) ) .+eq :  (A : Utype ->  (x :  (etype A)  ->  (_379 :  (etype A)  -> Uprop) ) ) .+refl_equal :  (A : Utype ->  (x :  (etype A)  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) .+case_13 :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_380 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_381 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (etype  (P y欧0) ) ) ) ) ) ) ) ) ) .+refl_equal_case_13 :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_383 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , P :  (_384 :  (etype A)  -> Utype) , f :  (etype  (P x) ) , y :  (etype A) , e :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (refl_equal_case_13 A)  x)  P)  f)  y)  e)  -->  ( (refl_equal A)  x) .+[A : Utype, x :  (etype A) , P :  (_382 :  (etype A)  -> Utype) , f :  (etype  (P x) ) , y :  (etype A) , e :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( ( ( (case_13 A)  x)  P)  f)  y)  e)  x)   ( ( ( ( ( (refl_equal_case_13 A)  x)  P)  f)  y)  e) )  --> f.+eq_rect :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_386 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (etype  (P y) ) ) ) ) ) ) ) .+[] eq_rect -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_385 :  (etype A)  => dottype) ) )  =>  (f :  (etype  (P x) )  =>  (y :  (etype A)  =>  (e :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( ( ( (case_13 A)  x)  P)  f)  y)  e)  y)  e) ) ) ) ) ) ) .+eq_ind :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_388 :  (etype A)  -> Uprop)  ->  (f :  (eprop  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  (P y) ) ) ) ) ) ) ) .+[] eq_ind -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_387 :  (etype A)  => dotprop) ) )  =>  ( ( (eq_rect A)  x)  P) ) ) ) .+eq_rec :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_390 :  (etype A)  -> Uset)  ->  (f :  (eset  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eset  (P y) ) ) ) ) ) ) ) .+[] eq_rec -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_389 :  (etype A)  => dotset) ) )  =>  ( ( (eq_rect A)  x)  P) ) ) ) .+case_14 :  (A : Uprop ->  (C : Uprop ->  (h1 :  (eprop A)  ->  (h2 :  (_391 :  (eprop A)  ->  (eprop False) )  ->  (f :  (eprop False)  ->  (_392 :  (eprop False)  ->  (eprop C) ) ) ) ) ) ) .+absurd :  (A : Uprop ->  (C : Uprop ->  (_396 :  (eprop A)  ->  (_395 :  (eprop  (not A) )  ->  (eprop C) ) ) ) ) .+[] absurd -->  (A :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (h1 :  (eprop A)  =>  (h2 :  (eprop  ( (dotpipp A)   (_394 :  (eprop A)  => False) ) )  =>  ( (f :  (eprop False)  =>  ( ( ( ( ( (case_14 A)  C)  h1)  h2)  f)  f) )   (h2 h1) ) ) ) ) ) .+case_15 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_397 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (eprop  ( ( (eq A)  y欧0)  x) ) ) ) ) ) ) ) .+refl_equal_case_15 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( (refl_equal_case_15 A)  x)  y)  H)  -->  ( (refl_equal A)  x) .+[A : Utype, x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (case_15 A)  x)  y)  H)  x)   ( ( ( (refl_equal_case_15 A)  x)  y)  H) )  -->  ( (refl_equal A)  x) .+sym_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_398 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  y)  x) ) ) ) ) ) .+[] sym_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( (case_15 A)  x)  y)  H)  y)  H) ) ) ) ) .+case_16 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (H0 :  (eprop  ( ( (eq A)  y)  z) )  ->  (y欧0 :  (etype A)  ->  (_399 :  (eprop  ( ( (eq A)  y)  y欧0) )  ->  (eprop  ( ( (eq A)  x)  y欧0) ) ) ) ) ) ) ) ) ) .+refl_equal_case_16 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (H0 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  y)  y) ) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , z :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) , H0 :  (eprop  ( ( (eq A)  y)  z) ) ]  ( ( ( ( ( (refl_equal_case_16 A)  x)  y)  z)  H)  H0)  -->  ( (refl_equal A)  y) .+[A : Utype, x :  (etype A) , y :  (etype A) , z :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) , H0 :  (eprop  ( ( (eq A)  y)  z) ) ]  ( ( ( ( ( ( ( (case_16 A)  x)  y)  z)  H)  H0)  y)   ( ( ( ( ( (refl_equal_case_16 A)  x)  y)  z)  H)  H0) )  --> H.+trans_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_401 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_400 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  x)  z) ) ) ) ) ) ) ) .+[] trans_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  (H0 :  (eprop  ( ( (eq A)  y)  z) )  =>  ( ( ( ( ( ( ( (case_16 A)  x)  y)  z)  H)  H0)  z)  H0) ) ) ) ) ) ) .+case_17 :  (A : Utype ->  (B : Utype ->  (f :  (_402 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_403 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (eprop  ( ( (eq B)   (f x) )   (f y欧0) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_17 :  (A : Utype ->  (B : Utype ->  (f :  (_405 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) ) ) .+[A : Utype, B : Utype, f :  (_406 :  (etype A)  ->  (etype B) ) , x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (refl_equal_case_17 A)  B)  f)  x)  y)  H)  -->  ( (refl_equal A)  x) .+[A : Utype, B : Utype, f :  (_404 :  (etype A)  ->  (etype B) ) , x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( ( ( (case_17 A)  B)  f)  x)  y)  H)  x)   ( ( ( ( ( (refl_equal_case_17 A)  B)  f)  x)  y)  H) )  -->  ( (refl_equal B)   (f x) ) .+f_equal :  (A : Utype ->  (B : Utype ->  (f :  (_408 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_409 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq B)   (f x) )   (f y) ) ) ) ) ) ) ) ) .+[] f_equal -->  (A :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A)   (_407 :  (etype A)  => B) ) )  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( ( ( (case_17 A)  B)  f)  x)  y)  H)  y)  H) ) ) ) ) ) ) .+case_18 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (h2 :  (eprop  ( ( (eq A)  y)  x) )  ->  (y欧0 :  (etype A)  ->  (_410 :  (eprop  ( ( (eq A)  y)  y欧0) )  ->  (h1欧0 :  (eprop  (not  ( ( (eq A)  y欧0)  y) ) )  ->  (eprop  ( ( (eq A)  y欧0)  y) ) ) ) ) ) ) ) ) ) .+refl_equal_case_18 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (h2 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eprop  ( ( (eq A)  y)  y) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) ) , h2 :  (eprop  ( ( (eq A)  y)  x) ) ]  ( ( ( ( (refl_equal_case_18 A)  x)  y)  h1)  h2)  -->  ( (refl_equal A)  y) .+[A : Utype, x :  (etype A) , y :  (etype A) , h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) ) , h2 :  (eprop  ( ( (eq A)  y)  x) ) ]  ( ( ( ( ( ( (case_18 A)  x)  y)  h1)  h2)  y)   ( ( ( ( (refl_equal_case_18 A)  x)  y)  h1)  h2) )  -->  (h1欧0 :  (eprop  (not  ( ( (eq A)  y)  y) ) )  =>  ( (refl_equal A)  y) ) .+sym_not_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_411 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (eprop  (not  ( ( (eq A)  y)  x) ) ) ) ) ) ) .+[] sym_not_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  =>  (h2 :  (eprop  ( ( (eq A)  y)  x) )  =>  (h1  ( ( ( ( ( ( ( (case_18 A)  x)  y)  h1)  h2)  x)  h2)  h1) ) ) ) ) ) ) .+sym_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_412 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  y)  x) ) ) ) ) ) .+[] sym_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  ( ( (sym_eq A)  x)  y) ) ) ) .+sym_not_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_413 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (eprop  (not  ( ( (eq A)  y)  x) ) ) ) ) ) ) .+[] sym_not_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  ( ( (sym_not_eq A)  x)  y) ) ) ) .+trans_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_415 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_414 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  x)  z) ) ) ) ) ) ) ) .+[] trans_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  ( ( ( (trans_eq A)  x)  y)  z) ) ) ) ) .+eq_ind_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_417 :  (etype A)  -> Uprop)  ->  (_419 :  (eprop  (P x) )  ->  (y :  (etype A)  ->  (_418 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eprop  (P y) ) ) ) ) ) ) ) .+[] eq_ind_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_416 :  (etype A)  => dotprop) ) )  =>  (H :  (eprop  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_ind A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+eq_rec_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_421 :  (etype A)  -> Uset)  ->  (_423 :  (eset  (P x) )  ->  (y :  (etype A)  ->  (_422 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eset  (P y) ) ) ) ) ) ) ) .+[] eq_rec_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_420 :  (etype A)  => dotset) ) )  =>  (H :  (eset  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_rec A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+eq_rect_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_425 :  (etype A)  -> Utype)  ->  (_427 :  (etype  (P x) )  ->  (y :  (etype A)  ->  (_426 :  (eprop  ( ( (eq A)  y)  x) )  ->  (etype  (P y) ) ) ) ) ) ) ) .+[] eq_rect_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_424 :  (etype A)  => dottype) ) )  =>  (H :  (etype  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_rect A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+case_19 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_429 :  (etype A1)  ->  (_428 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_431 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_430 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f y)  y2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_19 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_435 :  (etype A1)  ->  (_434 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_437 :  (etype A1)  ->  (_436 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( (refl_equal_case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  -->  ( (refl_equal A1)  x1) .+case_20 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_439 :  (etype A1)  ->  (_438 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_440 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f x1)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_20 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_444 :  (etype A1)  ->  (_443 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_446 :  (etype A1)  ->  (_445 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( (refl_equal_case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_442 :  (etype A1)  ->  (_441 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( (case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( (refl_equal_case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0) )  -->  ( (refl_equal B)   ( (f x1)  x2) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_433 :  (etype A1)  ->  (_432 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( (case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  x1)   ( ( ( ( ( ( ( ( (refl_equal_case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( (case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  y2)  H欧0) ) .+f_equal2 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_450 :  (etype A1)  ->  (_449 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (_452 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_451 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f y1)  y2) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal2 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_448 :  (etype A1)  =>  ( (dotpitt A2)   (_447 :  (etype A2)  => B) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( (case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  y1)  H) ) ) ) ) ) ) ) ) ) .+case_21 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_455 :  (etype A1)  ->  (_454 :  (etype A2)  ->  (_453 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_458 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_457 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_456 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f y)  y2)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_21 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_464 :  (etype A1)  ->  (_463 :  (etype A2)  ->  (_462 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_467 :  (etype A1)  ->  (_466 :  (etype A2)  ->  (_465 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  -->  ( (refl_equal A1)  x1) .+case_22 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_470 :  (etype A1)  ->  (_469 :  (etype A2)  ->  (_468 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_472 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_471 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f x1)  y)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_22 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_478 :  (etype A1)  ->  (_477 :  (etype A2)  ->  (_476 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_481 :  (etype A1)  ->  (_480 :  (etype A2)  ->  (_479 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_23 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_484 :  (etype A1)  ->  (_483 :  (etype A2)  ->  (_482 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_485 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f x1)  x2)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_23 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_491 :  (etype A1)  ->  (_490 :  (etype A2)  ->  (_489 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_494 :  (etype A1)  ->  (_493 :  (etype A2)  ->  (_492 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_488 :  (etype A1)  ->  (_487 :  (etype A2)  ->  (_486 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1) )  -->  ( (refl_equal B)   ( ( (f x1)  x2)  x3) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_475 :  (etype A1)  ->  (_474 :  (etype A2)  ->  (_473 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_461 :  (etype A1)  ->  (_460 :  (etype A2)  ->  (_459 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( (case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  y2)  H欧0) ) .+f_equal3 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_500 :  (etype A1)  ->  (_499 :  (etype A2)  ->  (_498 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (_503 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_502 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_501 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f y1)  y2)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal3 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_497 :  (etype A1)  =>  ( (dotpitt A2)   (_496 :  (etype A2)  =>  ( (dotpitt A3)   (_495 :  (etype A3)  => B) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( (case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) .+case_24 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_507 :  (etype A1)  ->  (_506 :  (etype A2)  ->  (_505 :  (etype A3)  ->  (_504 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_511 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_510 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_509 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_508 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f y)  y2)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_24 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_519 :  (etype A1)  ->  (_518 :  (etype A2)  ->  (_517 :  (etype A3)  ->  (_516 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_523 :  (etype A1)  ->  (_522 :  (etype A2)  ->  (_521 :  (etype A3)  ->  (_520 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  -->  ( (refl_equal A1)  x1) .+case_25 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_527 :  (etype A1)  ->  (_526 :  (etype A2)  ->  (_525 :  (etype A3)  ->  (_524 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_530 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_529 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_528 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  y)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_25 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_538 :  (etype A1)  ->  (_537 :  (etype A2)  ->  (_536 :  (etype A3)  ->  (_535 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_542 :  (etype A1)  ->  (_541 :  (etype A2)  ->  (_540 :  (etype A3)  ->  (_539 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_26 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_546 :  (etype A1)  ->  (_545 :  (etype A2)  ->  (_544 :  (etype A3)  ->  (_543 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_548 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (_547 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  x2)  y)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_26 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_556 :  (etype A1)  ->  (_555 :  (etype A2)  ->  (_554 :  (etype A3)  ->  (_553 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_560 :  (etype A1)  ->  (_559 :  (etype A2)  ->  (_558 :  (etype A3)  ->  (_557 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+case_27 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_564 :  (etype A1)  ->  (_563 :  (etype A2)  ->  (_562 :  (etype A3)  ->  (_561 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (y :  (etype A4)  ->  (_565 :  (eprop  ( ( (eq A4)  x4)  y) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  x2)  x3)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_27 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_573 :  (etype A1)  ->  (_572 :  (etype A2)  ->  (_571 :  (etype A3)  ->  (_570 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq A4)  x4)  x4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_577 :  (etype A1)  ->  (_576 :  (etype A2)  ->  (_575 :  (etype A3)  ->  (_574 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  -->  ( (refl_equal A4)  x4) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_569 :  (etype A1)  ->  (_568 :  (etype A2)  ->  (_567 :  (etype A3)  ->  (_566 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  x4)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2) )  -->  ( (refl_equal B)   ( ( ( (f x1)  x2)  x3)  x4) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_552 :  (etype A1)  ->  (_551 :  (etype A2)  ->  (_550 :  (etype A3)  ->  (_549 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1) )  -->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  y4)  H欧2) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_534 :  (etype A1)  ->  (_533 :  (etype A2)  ->  (_532 :  (etype A3)  ->  (_531 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_515 :  (etype A1)  ->  (_514 :  (etype A2)  ->  (_513 :  (etype A3)  ->  (_512 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  y2)  H欧0) ) .+f_equal4 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_585 :  (etype A1)  ->  (_584 :  (etype A2)  ->  (_583 :  (etype A3)  ->  (_582 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (_589 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_588 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_587 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_586 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f y1)  y2)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal4 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (A4 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_581 :  (etype A1)  =>  ( (dotpitt A2)   (_580 :  (etype A2)  =>  ( (dotpitt A3)   (_579 :  (etype A3)  =>  ( (dotpitt A4)   (_578 :  (etype A4)  => B) ) ) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (x4 :  (etype A4)  =>  (y4 :  (etype A4)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+case_28 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_594 :  (etype A1)  ->  (_593 :  (etype A2)  ->  (_592 :  (etype A3)  ->  (_591 :  (etype A4)  ->  (_590 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_599 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_598 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_597 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_596 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_595 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f y)  y2)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_28 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_609 :  (etype A1)  ->  (_608 :  (etype A2)  ->  (_607 :  (etype A3)  ->  (_606 :  (etype A4)  ->  (_605 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_614 :  (etype A1)  ->  (_613 :  (etype A2)  ->  (_612 :  (etype A3)  ->  (_611 :  (etype A4)  ->  (_610 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  -->  ( (refl_equal A1)  x1) .+case_29 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_619 :  (etype A1)  ->  (_618 :  (etype A2)  ->  (_617 :  (etype A3)  ->  (_616 :  (etype A4)  ->  (_615 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_623 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_622 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_621 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_620 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  y)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_29 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_633 :  (etype A1)  ->  (_632 :  (etype A2)  ->  (_631 :  (etype A3)  ->  (_630 :  (etype A4)  ->  (_629 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_638 :  (etype A1)  ->  (_637 :  (etype A2)  ->  (_636 :  (etype A3)  ->  (_635 :  (etype A4)  ->  (_634 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_30 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_643 :  (etype A1)  ->  (_642 :  (etype A2)  ->  (_641 :  (etype A3)  ->  (_640 :  (etype A4)  ->  (_639 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_646 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (_645 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_644 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  y)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_30 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_656 :  (etype A1)  ->  (_655 :  (etype A2)  ->  (_654 :  (etype A3)  ->  (_653 :  (etype A4)  ->  (_652 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_661 :  (etype A1)  ->  (_660 :  (etype A2)  ->  (_659 :  (etype A3)  ->  (_658 :  (etype A4)  ->  (_657 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+case_31 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_666 :  (etype A1)  ->  (_665 :  (etype A2)  ->  (_664 :  (etype A3)  ->  (_663 :  (etype A4)  ->  (_662 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (y :  (etype A4)  ->  (_668 :  (eprop  ( ( (eq A4)  x4)  y) )  ->  (_667 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  x3)  y)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_31 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_678 :  (etype A1)  ->  (_677 :  (etype A2)  ->  (_676 :  (etype A3)  ->  (_675 :  (etype A4)  ->  (_674 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq A4)  x4)  x4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_683 :  (etype A1)  ->  (_682 :  (etype A2)  ->  (_681 :  (etype A3)  ->  (_680 :  (etype A4)  ->  (_679 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  -->  ( (refl_equal A4)  x4) .+case_32 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_688 :  (etype A1)  ->  (_687 :  (etype A2)  ->  (_686 :  (etype A3)  ->  (_685 :  (etype A4)  ->  (_684 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (y :  (etype A5)  ->  (_689 :  (eprop  ( ( (eq A5)  x5)  y) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  x3)  x4)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_32 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_699 :  (etype A1)  ->  (_698 :  (etype A2)  ->  (_697 :  (etype A3)  ->  (_696 :  (etype A4)  ->  (_695 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq A5)  x5)  x5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_704 :  (etype A1)  ->  (_703 :  (etype A2)  ->  (_702 :  (etype A3)  ->  (_701 :  (etype A4)  ->  (_700 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) , H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  -->  ( (refl_equal A5)  x5) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_694 :  (etype A1)  ->  (_693 :  (etype A2)  ->  (_692 :  (etype A3)  ->  (_691 :  (etype A4)  ->  (_690 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) , H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  x5)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3) )  -->  ( (refl_equal B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_673 :  (etype A1)  ->  (_672 :  (etype A2)  ->  (_671 :  (etype A3)  ->  (_670 :  (etype A4)  ->  (_669 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  x4)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2) )  -->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  y5)  H欧3) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_651 :  (etype A1)  ->  (_650 :  (etype A2)  ->  (_649 :  (etype A3)  ->  (_648 :  (etype A4)  ->  (_647 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1) )  -->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  y4)  H欧2) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_628 :  (etype A1)  ->  (_627 :  (etype A2)  ->  (_626 :  (etype A3)  ->  (_625 :  (etype A4)  ->  (_624 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_604 :  (etype A1)  ->  (_603 :  (etype A2)  ->  (_602 :  (etype A3)  ->  (_601 :  (etype A4)  ->  (_600 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  y2)  H欧0) ) .+f_equal5 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_714 :  (etype A1)  ->  (_713 :  (etype A2)  ->  (_712 :  (etype A3)  ->  (_711 :  (etype A4)  ->  (_710 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (_719 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_718 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_717 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_716 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_715 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f y1)  y2)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal5 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (A4 :  (etype dottype)  =>  (A5 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_709 :  (etype A1)  =>  ( (dotpitt A2)   (_708 :  (etype A2)  =>  ( (dotpitt A3)   (_707 :  (etype A3)  =>  ( (dotpitt A4)   (_706 :  (etype A4)  =>  ( (dotpitt A5)   (_705 :  (etype A5)  => B) ) ) ) ) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (x4 :  (etype A4)  =>  (y4 :  (etype A4)  =>  (x5 :  (etype A5)  =>  (y5 :  (etype A5)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+subrelation :  (A : Utype ->  (B : Utype ->  (R :  (_726 :  (etype A)  ->  (_725 :  (etype B)  -> Uprop) )  ->  (R' :  (_728 :  (etype A)  ->  (_727 :  (etype B)  -> Uprop) )  -> Uprop) ) ) ) .+[] subrelation -->  (A :  (etype dottype)  =>  (B :  (etype dottype)  =>  (R :  (etype  ( (dotpitt A)   (_724 :  (etype A)  =>  ( (dotpitt B)   (_723 :  (etype B)  => dotprop) ) ) ) )  =>  (R' :  (etype  ( (dotpitt A)   (_722 :  (etype A)  =>  ( (dotpitt B)   (_721 :  (etype B)  => dotprop) ) ) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpitp B)   (y :  (etype B)  =>  ( (dotpipp  ( (R x)  y) )   (_720 :  (eprop  ( (R x)  y) )  =>  ( (R' x)  y) ) ) ) ) ) ) ) ) ) ) .+unique :  (A : Utype ->  (P :  (_731 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  -> Uprop) ) ) .+[] unique -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_730 :  (etype A)  => dotprop) ) )  =>  (x :  (etype A)  =>  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_729 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) ) ) ) .+uniqueness :  (A : Utype ->  (P :  (_735 :  (etype A)  -> Uprop)  -> Uprop) ) .+[] uniqueness -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_734 :  (etype A)  => dotprop) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpitp A)   (y :  (etype A)  =>  ( (dotpipp  (P x) )   (_733 :  (eprop  (P x) )  =>  ( (dotpipp  (P y) )   (_732 :  (eprop  (P y) )  =>  ( ( (eq A)  x)  y) ) ) ) ) ) ) ) ) ) ) .+case_33 :  (A : Utype ->  (P :  (_738 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (_739 :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) ) .+conj_case_33 :  (A : Utype ->  (P :  (_741 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (_743 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_742 :  (eprop  ( (uniqueness A)  P) )  ->  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) ) .+[A : Utype, P :  (_744 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ]  ( ( (conj_case_33 A)  P)  H)  -->  ( (conj  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) .+case_34 :  (A : Utype ->  (P :  (_745 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_747 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_746 :  (eprop  ( (uniqueness A)  P) )  ->  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) ) ) ) .+ex_intro_case_34 :  (A : Utype ->  (P :  (_749 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (x :  (etype A)  ->  (_750 :  (eprop  ( (x欧0 :  (etype A)  =>  (P x欧0) )  x) )  ->  (eprop  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_751 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) ]  ( ( ( (ex_intro_case_34 A)  P)  H)  H欧0)  -->  ( (ex_intro A)   (x :  (etype A)  =>  (P x) ) ) .+[A : Utype, P :  (_748 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_25 :  (etype A) , var_26 :  (eprop  ( (x :  (etype A)  =>  (P x) )  var_25) ) ]  ( ( ( ( (case_34 A)  P)  H)  H欧0)   ( ( ( ( ( (ex_intro_case_34 A)  P)  H)  H欧0)  var_25)  var_26) )  -->  ( ( (x :  (etype A)  =>  (Hx :  (eprop  (P x) )  =>  (Huni :  (eprop  ( (uniqueness A)  P) )  =>  ( ( ( (ex_intro A)   ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  x)   ( ( ( (conj  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_752 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) )  Hx)   (x' :  (etype A)  =>  (H欧1 :  (eprop  (P x') )  =>  ( ( ( (Huni x)  x')  Hx)  H欧1) ) ) ) ) ) ) )  var_25)  var_26) .+[A : Utype, P :  (_740 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , var_23 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_24 :  (eprop  ( (uniqueness A)  P) ) ]  ( ( ( (case_33 A)  P)  H)   ( ( ( ( (conj_case_33 A)  P)  H)  var_23)  var_24) )  -->  ( ( (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  =>  ( ( ( ( (case_34 A)  P)  H)  H欧0)  H欧0) )  var_23)  var_24) .+case_35 :  (A : Utype ->  (P :  (_753 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (_754 :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) .+ex_intro_case_35 :  (A : Utype ->  (P :  (_756 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (_757 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (eprop  ( (ex A)   ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_758 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ]  ( ( (ex_intro_case_35 A)  P)  H)  -->  ( (ex_intro A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) .+case_36 :  (A : Utype ->  (P :  (_759 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (_761 :  (eprop  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_760 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) )  ->  (eprop  ( (and  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) ) ) .+conj_case_36 :  (A : Utype ->  (P :  (_764 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (_768 :  (eprop  (P x) )  ->  (_767 :  (x' :  (etype A)  ->  (_765 :  (eprop  (P x') )  ->  (eprop  ( ( (eq A)  x)  x') ) ) )  ->  (eprop  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_766 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_769 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , x :  (etype A) , H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) ) ]  ( ( ( ( (conj_case_36 A)  P)  H)  x)  H欧0)  -->  ( (conj  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_763 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) .+[A : Utype, P :  (_762 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , x :  (etype A) , H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) ) , var_29 :  (eprop  (P x) ) , var_30 :  (x' :  (etype A)  ->  (_770 :  (eprop  (P x') )  ->  (eprop  ( ( (eq A)  x)  x') ) ) ) ]  ( ( ( ( ( (case_36 A)  P)  H)  x)  H欧0)   ( ( ( ( ( ( (conj_case_36 A)  P)  H)  x)  H欧0)  var_29)  var_30) )  -->  ( ( (Hx :  (eprop  (P x) )  =>  (Huni :  (eprop  ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_771 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) )  =>  ( ( ( (conj  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )   ( (uniqueness A)  P) )   ( ( ( (ex_intro A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x)  Hx) )   (x' :  (etype A)  =>  (x'' :  (etype A)  =>  (Hx' :  (eprop  (P x') )  =>  (Hx'' :  (eprop  (P x'') )  =>  ( ( ( ( ( (trans_eq A)  x')  x)  x'')   ( ( ( (sym_eq A)  x)  x')   ( (Huni x')  Hx') ) )   ( (Huni x'')  Hx'') ) ) ) ) ) ) ) )  var_29)  var_30) .+[A : Utype, P :  (_755 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , var_27 :  (etype A) , var_28 :  (eprop  ( ( (unique A)   (x :  (etype A)  =>  (P x) ) )  var_27) ) ]  ( ( ( (case_35 A)  P)  H)   ( ( ( ( (ex_intro_case_35 A)  P)  H)  var_27)  var_28) )  -->  ( ( (x :  (etype A)  =>  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  =>  ( ( ( ( ( (case_36 A)  P)  H)  x)  H欧0)  H欧0) ) )  var_27)  var_28) .+unique_existence :  (A : Utype ->  (P :  (_773 :  (etype A)  -> Uprop)  ->  (eprop  ( (iff  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )   ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) .+[] unique_existence -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_772 :  (etype A)  => dotprop) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )   (_736 :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  =>  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) )   ( (dotpipp  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )   (_737 :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  =>  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) )   (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  =>  ( ( ( (case_33 A)  P)  H)  H) ) )   (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  =>  ( ( ( (case_35 A)  P)  H)  H) ) ) ) ) .+inhabited :  (A : Utype -> Uprop) .+inhabits :  (A : Utype ->  (_774 :  (etype A)  ->  (eprop  (inhabited A) ) ) ) .+case_37 :  (A : Utype ->  (P : Uprop ->  (f :  (_775 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (_776 :  (eprop  (inhabited A) )  ->  (eprop P) ) ) ) ) ) .+inhabits_case_37 :  (A : Utype ->  (P : Uprop ->  (f :  (_778 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (_779 :  (etype A)  ->  (eprop  (inhabited A) ) ) ) ) ) ) .+[A : Utype, P : Uprop, f :  (_780 :  (etype A)  ->  (eprop P) ) , i :  (eprop  (inhabited A) ) ]  ( ( ( (inhabits_case_37 A)  P)  f)  i)  -->  (inhabits A) .+[A : Utype, P : Uprop, f :  (_777 :  (etype A)  ->  (eprop P) ) , i :  (eprop  (inhabited A) ) , var_31 :  (etype A) ]  ( ( ( ( (case_37 A)  P)  f)  i)   ( ( ( ( (inhabits_case_37 A)  P)  f)  i)  var_31) )  -->  (f var_31) .+inhabited_ind :  (A : Utype ->  (P : Uprop ->  (f :  (_782 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (eprop P) ) ) ) ) .+[] inhabited_ind -->  (A :  (etype dottype)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (_781 :  (etype A)  => P) ) )  =>  (i :  (eprop  (inhabited A) )  =>  ( ( ( ( (case_37 A)  P)  f)  i)  i) ) ) ) ) .+case_38 :  (A : Utype ->  (P :  (_783 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_784 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (eprop  (inhabited A) ) ) ) ) ) .+ex_intro_case_38 :  (A : Utype ->  (P :  (_786 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (x :  (etype A)  ->  (_787 :  (eprop  ( (x欧0 :  (etype A)  =>  (P x欧0) )  x) )  ->  (eprop  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_788 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) ]  ( ( (ex_intro_case_38 A)  P)  H)  -->  ( (ex_intro A)   (x :  (etype A)  =>  (P x) ) ) .+[A : Utype, P :  (_785 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_32 :  (etype A) , var_33 :  (eprop  ( (x :  (etype A)  =>  (P x) )  var_32) ) ]  ( ( ( (case_38 A)  P)  H)   ( ( ( ( (ex_intro_case_38 A)  P)  H)  var_32)  var_33) )  -->  ( ( (x :  (etype A)  =>  (H欧0 :  (eprop  (P x) )  =>  ( (inhabits A)  x) ) )  var_32)  var_33) .+exists_inhabited :  (A : Utype ->  (P :  (_790 :  (etype A)  -> Uprop)  ->  (_791 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (eprop  (inhabited A) ) ) ) ) .+[] exists_inhabited -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_789 :  (etype A)  => dotprop) ) )  =>  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  =>  ( ( ( (case_38 A)  P)  H)  H) ) ) ) .+eq_stepl :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_793 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_792 :  (eprop  ( ( (eq A)  x)  z) )  ->  (eprop  ( ( (eq A)  z)  y) ) ) ) ) ) ) ) .+[] eq_stepl -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  (H1 :  (eprop  ( ( (eq A)  x)  y) )  =>  (H2 :  (eprop  ( ( (eq A)  x)  z) )  =>  ( ( ( ( ( (eq_ind A)  x)   (z欧0 :  (etype A)  =>  ( ( (eq A)  z欧0)  y) ) )  H1)  z)  H2) ) ) ) ) ) ) .+iff_stepl :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_805 :  (eprop  ( (iff A)  B) )  ->  (_804 :  (eprop  ( (iff A)  C) )  ->  (eprop  ( (iff C)  B) ) ) ) ) ) ) .+[] iff_stepl -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  (H0 :  (eprop  ( (iff A)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_794 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_795 :  (eprop B)  => A) ) )   ( (iff C)  B) )   (H1 :  (eprop  ( (dotpipp A)   (_803 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_802 :  (eprop B)  => A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_796 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_797 :  (eprop C)  => A) ) )   ( (iff C)  B) )   (H欧0 :  (eprop  ( (dotpipp A)   (_801 :  (eprop A)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_800 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp C)   (_798 :  (eprop C)  => B) ) )   ( (dotpipp B)   (_799 :  (eprop B)  => C) ) )   (H0欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H3欧0 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop A)  => H3欧0)   (H2 H3欧0) ) )   (H欧0 H4) ) )   (H1 H4) ) )   (H3 H0欧0) ) ) )   (H0欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H2欧0 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop A)  => H1欧0)   (H3 H1欧0) ) )   (H欧0 H4) ) )   (H1 H4) ) )   (H2 H0欧0) ) ) ) ) ) )  H0) ) ) )  H) ) ) ) ) ) .+;Finished module Logic
+ t/Logicavecprelude.eu view
@@ -0,0 +1,156 @@+Uset : Type.+Uprop : Type.+Utype : Type.++eprop : x : Uprop -> Type.+eset : x : Uset -> Type.+etype : x : Utype -> Type.++dotset : Utype.+dotprop : Utype.++; /!\ type : type /!\, should use universes+dottype : Utype.++; /!\ subtyping in coq, should be unidirectional /!\+[] Uprop --> Utype.+[] Uset --> Utype.++dotpipp : x : Uprop -> y : (eprop x -> Uprop) -> Uprop.+dotpips : x : Uprop -> y : (eprop x -> Uset)  -> Uset.+dotpipt : x : Uprop -> y : (eprop x -> Utype) -> Utype.+dotpisp : x : Uset  -> y : (eset x  -> Uprop) -> Uprop.+dotpitp : x : Utype -> y : (etype x -> Uprop) -> Uprop.+dotpist : x : Uset  -> y : (eset  x -> Utype) -> Utype.+dotpits : x : Utype -> y : (etype x -> Uset)  -> Uset.+dotpiss : x : Uset  -> y : (eset x  -> Uset)  -> Uset.+dotpitt : x : Utype -> y : (etype x -> Utype) -> Utype.+++[x:Uprop, y : eprop x -> Uprop]+              eprop (dotpipp x y) --> w : eprop x -> eprop (y w).++[x:Uset, y : eset x -> Uprop]+              eprop (dotpisp x y) --> w : eset x -> eprop (y w).++[x:Utype, y : etype x -> Uprop]+              eprop (dotpitp x y) --> w : etype x -> eprop (y w).++; /!\+[P : Uprop] eprop P --> etype P.++[x:Uprop, y : eprop x -> Uset]+              eset (dotpips x y) --> w : eprop x -> eset (y w).++[x:Utype, y : etype x -> Uset]+              eset (dotpits x y) --> w : etype x -> eset (y w).++[x:Uset, y : eset x -> Uset]+              eset (dotpiss x y) --> w : eset x -> eset (y w).++; /!\+[P : Uset] eset P --> etype P.++[x:Uset, y : eset x -> Utype]+              etype (dotpist x y) --> w : eset x -> etype (y w).++[x:Utype, y : etype x -> Utype]+              etype (dotpitt x y) --> w : etype x -> etype (y w).++[x:Uprop, y : eprop x -> Utype]+              etype (dotpipt x y) --> w : eprop x -> etype (y w).+++[] (etype dotset)  --> Uset.+[] (etype dotprop) --> Uprop.+; /!\+[] (etype dottype) --> Utype.++; end of Coq1univ++True : Uprop.+I :  (eprop True) .+case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (_0 :  (eprop True)  ->  (etype P) ) ) ) ) .+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( ( (case_0 P)  f)  t)  I)  --> f.+True_rect :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (etype P) ) ) ) .+[] True_rect -->  (P :  (etype dottype)  =>  (f :  (etype P)  =>  (t :  (eprop True)  =>  ( ( ( (case_0 P)  f)  t)  t) ) ) ) .+True_ind :  (P : Uprop ->  (f :  (eprop P)  ->  (t :  (eprop True)  ->  (eprop P) ) ) ) .+[] True_ind -->  (P :  (etype dotprop)  =>  (True_rect P) ) .+True_rec :  (P : Uset ->  (f :  (eset P)  ->  (t :  (eprop True)  ->  (eset P) ) ) ) .+[] True_rec -->  (P :  (etype dotset)  =>  (True_rect P) ) .+False : Uprop.+case_1 :  (P : Utype ->  (f :  (eprop False)  ->  (_1 :  (eprop False)  ->  (etype P) ) ) ) .+False_rect :  (P : Utype ->  (f :  (eprop False)  ->  (etype P) ) ) .+[] False_rect -->  (P :  (etype dottype)  =>  (f :  (eprop False)  =>  ( ( (case_1 P)  f)  f) ) ) .+False_ind :  (P : Uprop ->  (f :  (eprop False)  ->  (eprop P) ) ) .+[] False_ind -->  (P :  (etype dotprop)  =>  (False_rect P) ) .+False_rec :  (P : Uset ->  (f :  (eprop False)  ->  (eset P) ) ) .+[] False_rec -->  (P :  (etype dotset)  =>  (False_rect P) ) .+not :  (A : Uprop -> Uprop) .+[] not -->  (A :  (etype dotprop)  =>  ( (dotpipp A)   (_2 :  (eprop A)  => False) ) ) .+and :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+conj :  (A : Uprop ->  (B : Uprop ->  (_4 :  (eprop A)  ->  (_3 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) .+case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_6 :  (eprop A)  ->  (_5 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_7 :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Utype, f :  (_9 :  (eprop A)  ->  (_8 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) , var_0 :  (eprop A) , var_1 :  (eprop B) ]  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)   ( ( ( (conj A)  B)  var_0)  var_1) )  -->  ( (f var_0)  var_1) .+and_rect :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_13 :  (eprop A)  ->  (_12 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) .+[] and_rect -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dottype)  =>  (f :  (etype  ( (dotpipt A)   (_11 :  (eprop A)  =>  ( (dotpipt B)   (_10 :  (eprop B)  => P) ) ) ) )  =>  (a :  (eprop  ( (and A)  B) )  =>  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)  a) ) ) ) ) ) .+and_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_15 :  (eprop A)  ->  (_14 :  (eprop B)  ->  (eprop P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eprop P) ) ) ) ) ) .+[] and_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+and_rec :  (A : Uprop ->  (B : Uprop ->  (P : Uset ->  (f :  (_17 :  (eprop A)  ->  (_16 :  (eprop B)  ->  (eset P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eset P) ) ) ) ) ) .+[] and_rec -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotset)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_18 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_2 :  (eprop A) , var_3 :  (eprop B) ]  ( ( ( (case_3 A)  B)  H)   ( ( ( (conj A)  B)  var_2)  var_3) )  -->  ( ( (H0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_2)  var_3) .+proj1 :  (A : Uprop ->  (B : Uprop ->  (_19 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) .+[] proj1 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_3 A)  B)  H)  H) ) ) ) .+case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_20 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_4 :  (eprop A) , var_5 :  (eprop B) ]  ( ( ( (case_4 A)  B)  H)   ( ( ( (conj A)  B)  var_4)  var_5) )  -->  ( ( (H0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_4)  var_5) .+proj2 :  (A : Uprop ->  (B : Uprop ->  (_21 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) .+[] proj2 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_4 A)  B)  H)  H) ) ) ) .+or :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+or_introl :  (A : Uprop ->  (B : Uprop ->  (_22 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) .+or_intror :  (A : Uprop ->  (B : Uprop ->  (_23 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) .+case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_24 :  (eprop A)  ->  (eprop P) )  ->  (f0 :  (_25 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_26 :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_27 :  (eprop A)  ->  (eprop P) ) , f0 :  (_28 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_6 :  (eprop A) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)   ( ( (or_introl A)  B)  var_6) )  -->  (f var_6) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_27 :  (eprop A)  ->  (eprop P) ) , f0 :  (_28 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_7 :  (eprop B) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)   ( ( (or_intror A)  B)  var_7) )  -->  (f0 var_7) .+or_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_31 :  (eprop A)  ->  (eprop P) )  ->  (f0 :  (_32 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) .+[] or_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpipp A)   (_30 :  (eprop A)  => P) ) )  =>  (f0 :  (eprop  ( (dotpipp B)   (_29 :  (eprop B)  => P) ) )  =>  (o :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)  o) ) ) ) ) ) ) .+iff :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+[] iff -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( (and  ( (dotpipp A)   (_33 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_34 :  (eprop B)  => A) ) ) ) ) .+iff_refl :  (A : Uprop ->  (eprop  ( (iff A)  A) ) ) .+[] iff_refl -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp A)   (_35 :  (eprop A)  => A) ) )   ( (dotpipp A)   (_36 :  (eprop A)  => A) ) )   (H :  (eprop A)  => H) )   (H :  (eprop A)  => H) ) ) .+case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_40 :  (eprop  ( (and  ( (dotpipp A)   (_37 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_38 :  (eprop B)  => A) ) ) )  ->  (_39 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) .+case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_41 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_42 :  (eprop B)  ->  (eprop A) )  ->  (H0 :  (eprop  ( (iff B)  C) )  ->  (_45 :  (eprop  ( (and  ( (dotpipp B)   (_43 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_44 :  (eprop C)  => B) ) ) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_46 :  (eprop A)  ->  (eprop B) ) , H2 :  (_47 :  (eprop B)  ->  (eprop A) ) , H0 :  (eprop  ( (iff B)  C) ) , var_10 :  (eprop B) , var_11 :  (eprop C) ]  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H0)   ( ( ( (conj B)  C)  var_10)  var_11) )  -->  ( ( (H3 :  (eprop  ( (dotpipp B)   (_51 :  (eprop B)  => C) ) )  =>  (H4 :  (eprop  ( (dotpipp C)   (_50 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_48 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_49 :  (eprop C)  => A) ) )   (H1 :  (eprop A)  =>  (H3  (H1 H1) ) ) )   (H1 :  (eprop C)  =>  (H2  (H1  (H2  (H4 H1) ) ) ) ) ) ) )  var_10)  var_11) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , var_8 :  (eprop A) , var_9 :  (eprop B) ]  ( ( ( ( (case_6 A)  B)  C)  H)   ( ( ( (conj A)  B)  var_8)  var_9) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_53 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_52 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H0)  H0) ) ) )  var_8)  var_9) .+iff_trans :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_55 :  (eprop  ( (iff A)  B) )  ->  (_54 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) .+[] iff_trans -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (case_6 A)  B)  C)  H)  H) ) ) ) ) .+case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_58 :  (eprop  ( (and  ( (dotpipp A)   (_56 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_57 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (iff B)  A) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_12 :  (eprop A) , var_13 :  (eprop B) ]  ( ( ( (case_8 A)  B)  H)   ( ( ( (conj A)  B)  var_12)  var_13) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_62 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_61 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_59 :  (eprop B)  => A) ) )   ( (dotpipp A)   (_60 :  (eprop A)  => B) ) )  H2)  H1) ) )  var_12)  var_13) .+iff_sym :  (A : Uprop ->  (B : Uprop ->  (_63 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (iff B)  A) ) ) ) ) .+[] iff_sym -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_8 A)  B)  H)  H) ) ) ) .+case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_74 :  (eprop  ( (and  ( (dotpipp A)   (_71 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_72 :  (eprop False)  => A) ) ) )  ->  (_73 :  (eprop A)  ->  (eprop False) ) ) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) , var_14 :  (eprop A) , var_15 :  (eprop False) ]  ( ( (case_9 A)  H)   ( ( ( (conj A)  False)  var_14)  var_15) )  -->  ( ( (H0 :  (eprop  ( (dotpipp A)   (_76 :  (eprop A)  => False) ) )  =>  (H0 :  (eprop  ( (dotpipp False)   (_75 :  (eprop False)  => A) ) )  => H0) )  var_14)  var_15) .+neg_false :  (A : Uprop ->  (eprop  ( (iff  (not A) )   ( (iff A)  False) ) ) ) .+[] neg_false -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (dotpipp A)   (_64 :  (eprop A)  => False) ) )   (_65 :  (eprop  ( (dotpipp A)   (_64 :  (eprop A)  => False) ) )  =>  ( (iff A)  False) ) ) )   ( (dotpipp  ( (iff A)  False) )   (_67 :  (eprop  ( (iff A)  False) )  =>  ( (dotpipp A)   (_66 :  (eprop A)  => False) ) ) ) )   (H :  (eprop  ( (dotpipp A)   (_70 :  (eprop A)  => False) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_68 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_69 :  (eprop False)  => A) ) )  H)   (H1 :  (eprop False)  =>  ( (False_ind A)  H1) ) ) ) )   (H :  (eprop  ( (iff A)  False) )  =>  ( ( (case_9 A)  H)  H) ) ) ) .+and_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_104 :  (_101 :  (eprop B)  ->  (eprop A) )  ->  (_103 :  (_102 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_100 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_99 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (_77 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_78 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and A)  B) )   (_79 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_80 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and A)  B) )   (_92 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and A)  C) )   (_91 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp A)   (_90 :  (eprop A)  =>  ( (dotpipp B)   (_89 :  (eprop B)  =>  ( (and A)  C) ) ) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp A)   (_88 :  (eprop A)  =>  ( (dotpipp C)   (_87 :  (eprop C)  =>  ( (and A)  B) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_81 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_82 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp B)   (_84 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H11 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  C)   (H1 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H12 :  (eprop  ( (dotpipp C)   (_83 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H21 :  (eprop A)  =>  ( (H00 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  C)   (H13 :  (eprop A)  =>  (H6 :  (eprop B)  => H5) ) )  H00) )   (H12 H5) ) )   (H0 H5) ) )   (H20 H4) ) ) ) )  H11) )   (H0 H30) ) )   (H10 H4) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp B)   (_86 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H11 :  (eprop  ( (dotpipp C)   (_85 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H21 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  B)   (H12 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H22 :  (eprop A)  =>  ( (H0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  B)   (H01 :  (eprop A)  =>  (H6 :  (eprop C)  => H5) ) )  H0) )   (H00 H5) ) )   (H H5) ) ) ) )  H21) )   (H11 H30) ) )   (H20 H4) ) )   (H10 H4) ) )   (H0 H30) ) ) ) )   (H20 :  (eprop A)  =>  (H4 :  (eprop C)  =>  (H3  ( ( ( (conj A)  C)  H20)  H4) ) ) ) ) )   (H10 :  (eprop A)  =>  (H4 :  (eprop B)  =>  (H2  ( ( ( (conj A)  B)  H10)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_93 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_94 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_98 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_97 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_95 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_96 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H10 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H4 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H11 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj A)  C)  H20)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H5) ) )   (H H5) ) ) ) )  H10) ) )   (H10 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H4 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H11 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H30)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H5) ) )   (H0 H5) ) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_132 :  (_129 :  (eprop B)  ->  (eprop A) )  ->  (_131 :  (_130 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_128 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_127 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (_105 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_106 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and B)  A) )   (_107 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_108 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and B)  A) )   (_120 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and C)  A) )   (_119 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp B)   (_118 :  (eprop B)  =>  ( (dotpipp A)   (_117 :  (eprop A)  =>  ( (and C)  A) ) ) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp C)   (_116 :  (eprop C)  =>  ( (dotpipp A)   (_115 :  (eprop A)  =>  ( (and B)  A) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_109 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_110 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp A)   (_112 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H11 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  C)   (H1 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H12 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp A)   (_111 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H21 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  C)   (H01 :  (eprop B)  =>  (H6 :  (eprop A)  => H1) ) )  H21) )   (H00 H4) ) )   (H20 H1) ) )   (H0 H1) ) ) ) )  H11) )   (H0 H4) ) )   (H10 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp A)   (_114 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H21 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  B)   (H01 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H22 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp A)   (_113 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H11 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  B)   (H1 :  (eprop C)  =>  (H6 :  (eprop A)  => H01) ) )  H11) )   (H0 H4) ) )   (H10 H01) ) )   (H H01) ) ) ) )  H21) )   (H00 H4) ) )   (H20 H30) ) )   (H0 H30) ) ) ) )   (H20 :  (eprop C)  =>  (H4 :  (eprop A)  =>  (H3  ( ( ( (conj C)  A)  H20)  H4) ) ) ) ) )   (H10 :  (eprop B)  =>  (H4 :  (eprop A)  =>  (H2  ( ( ( (conj B)  A)  H10)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_121 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_122 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_126 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_125 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_123 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_124 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H10 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H4 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H11 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj C)  A)  H0)  H20) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) ) )  H10) ) )   (H10 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H4 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H11 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H00)  H30) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_156 :  (_153 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_155 :  (_154 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_152 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_151 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (_133 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_134 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or A)  B) )   (_135 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_136 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or A)  B) )   (_144 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or A)  C) )   (_143 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp A)   (_142 :  (eprop A)  =>  ( (or A)  C) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp B)   (_141 :  (eprop B)  =>  ( (or A)  C) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp A)   (_140 :  (eprop A)  =>  ( (or A)  B) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp C)   (_139 :  (eprop C)  =>  ( (or A)  B) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_137 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_138 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H40 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H11 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )   (H11 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (False_ind C)  H00) ) )   (H50 :  (eprop B)  =>  ( (False_ind C)  H00) ) )  H61) )   (H5 H11) ) )   (H60 H40) ) )   (H0 H11) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (False_ind C)  H00) ) )   (H50 :  (eprop B)  =>  ( (False_ind C)  H00) ) )  H61) )   (H5 H11) ) )   (H60 H40) ) )   (H0 H11) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )  H1) )   (H10 H40) ) ) )   (H40 :  (eprop C)  =>  ( (H1 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H11 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )   (H11 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )  H01) )   (H10 H50) ) ) )   (H50 :  (eprop B)  => H40) )  H00) )   (H5 H40) ) )   (H0 H40) ) ) )  H0) )   (H4 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H50 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H11 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (False_ind B)  H0) ) )   (H40 :  (eprop C)  =>  ( (False_ind B)  H0) ) )  H61) )   (H4 H21) ) )   (H60 H50) ) )   (H H21) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )   (H11 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (False_ind B)  H0) ) )   (H40 :  (eprop C)  =>  ( (False_ind B)  H0) ) )  H61) )   (H4 H21) ) )   (H60 H50) ) )   (H H21) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )  H01) )   (H10 H50) ) ) )   (H50 :  (eprop B)  =>  ( (H01 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H11 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )   (H11 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )  H1) )   (H10 H40) ) ) )   (H40 :  (eprop C)  => H50) )  H0) )   (H4 H50) ) )   (H H50) ) ) )  H00) )   (H5 H30) ) )   (H0 H30) ) ) ) )   (H5 :  (eprop C)  =>  (H3  ( ( (or_intror A)  C)  H5) ) ) ) )   (H20 :  (eprop A)  =>  (H3  ( ( (or_introl A)  C)  H20) ) ) ) )   (H4 :  (eprop B)  =>  (H2  ( ( (or_intror A)  B)  H4) ) ) ) )   (H10 :  (eprop A)  =>  (H2  ( ( (or_introl A)  B)  H10) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_145 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_146 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_150 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_149 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_147 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_148 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H10 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  C)  H4) ) )   (H4 :  (eprop B)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( ( (or_intror A)  C)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) )  H10) ) )   (H10 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  B)  H4) ) )   (H4 :  (eprop C)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_180 :  (_177 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_179 :  (_178 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_176 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_175 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (_157 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_158 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or B)  A) )   (_159 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_160 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or B)  A) )   (_168 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or C)  A) )   (_167 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp B)   (_166 :  (eprop B)  =>  ( (or C)  A) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp A)   (_165 :  (eprop A)  =>  ( (or C)  A) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp C)   (_164 :  (eprop C)  =>  ( (or B)  A) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp A)   (_163 :  (eprop A)  =>  ( (or B)  A) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_161 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_162 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H11 :  (eprop C)  =>  ( (H1 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  => H11) )   (H21 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H40 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )   (H40 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )  H01) )   (H4 H21) ) ) )  H00) )   (H20 H11) ) )   (H0 H11) ) ) )   (H11 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H40 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  =>  ( (False_ind C)  H00) ) )   (H21 :  (eprop A)  =>  ( (False_ind C)  H00) ) )  H61) )   (H20 H40) ) )   (H60 H11) ) )   (H0 H40) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  =>  ( (False_ind C)  H00) ) )   (H21 :  (eprop A)  =>  ( (False_ind C)  H00) ) )  H61) )   (H20 H40) ) )   (H60 H11) ) )   (H0 H40) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )   (H40 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )  H1) )   (H4 H11) ) ) )  H0) )   (H10 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H21 :  (eprop B)  =>  ( (H01 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  => H21) )   (H11 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H40 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )   (H40 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )  H1) )   (H4 H11) ) ) )  H0) )   (H10 H21) ) )   (H H21) ) ) )   (H21 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H40 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  =>  ( (False_ind B)  H0) ) )   (H11 :  (eprop A)  =>  ( (False_ind B)  H0) ) )  H61) )   (H10 H50) ) )   (H60 H21) ) )   (H H50) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )   (H40 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  =>  ( (False_ind B)  H0) ) )   (H11 :  (eprop A)  =>  ( (False_ind B)  H0) ) )  H61) )   (H10 H50) ) )   (H60 H21) ) )   (H H50) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )  H01) )   (H4 H21) ) ) )  H00) )   (H20 H30) ) )   (H0 H30) ) ) ) )   (H5 :  (eprop A)  =>  (H3  ( ( (or_intror C)  A)  H5) ) ) ) )   (H20 :  (eprop C)  =>  (H3  ( ( (or_introl C)  A)  H20) ) ) ) )   (H4 :  (eprop A)  =>  (H2  ( ( (or_intror B)  A)  H4) ) ) ) )   (H10 :  (eprop B)  =>  (H2  ( ( (or_introl B)  A)  H10) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_169 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_170 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_174 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_173 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_171 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_172 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H10 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H4 :  (eprop B)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( ( (or_introl C)  A)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror C)  A)  H4) ) )  H10) ) )   (H10 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H4 :  (eprop C)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror B)  A)  H4) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_187 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) ) ) ) .+[] and_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_181 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_182 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_186 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_185 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_183 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_184 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H2 :  (eprop A)  =>  (H3 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2)  H1) )   (H1 H1) ) )   (H0 H3) ) ) ) )  H0) ) )   (H0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H2 :  (eprop A)  =>  (H3 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( ( (conj A)  B)  H2)  H1) )   (H0 H1) ) )   (H1 H3) ) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+and_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_194 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) ) ) ) .+[] and_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_188 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_189 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_193 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_192 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_190 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_191 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H2 :  (eprop B)  =>  (H3 :  (eprop A)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj C)  A)  H1)  H3) )   (H1 H1) ) )   (H0 H2) ) ) ) )  H0) ) )   (H0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H2 :  (eprop C)  =>  (H3 :  (eprop A)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( ( (conj B)  A)  H1)  H3) )   (H0 H1) ) )   (H1 H2) ) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_201 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) ) ) ) .+[] or_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_195 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_196 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_200 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_199 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_197 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_198 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  C)  H2) ) )   (H2 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( (or_intror A)  C)  H1) )   (H1 H1) ) )   (H0 H2) ) ) )  H0) ) )   (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  B)  H2) ) )   (H2 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( (or_intror A)  B)  H1) )   (H0 H1) ) )   (H1 H2) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_208 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) ) ) ) .+[] or_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_202 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_203 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_207 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_206 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_204 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_205 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H2 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( (or_introl C)  A)  H1) )   (H1 H1) ) )   (H0 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror C)  A)  H2) ) )  H0) ) )   (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H2 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( (or_introl B)  A)  H1) )   (H0 H1) ) )   (H1 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror B)  A)  H2) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_213 :  (eprop  ( (and  ( (dotpipp A)   (_209 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_210 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (and  ( (dotpipp A)   (_211 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_212 :  (eprop B)  => A) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_16 :  (eprop A) , var_17 :  (eprop B) ]  ( ( ( (case_10 A)  B)  H)   ( ( ( (conj A)  B)  var_16)  var_17) )  -->  ( ( (H0 :  (eprop  ( (dotpipp A)   (_217 :  (eprop A)  => B) ) )  =>  (H0 :  (eprop  ( (dotpipp B)   (_216 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_214 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_215 :  (eprop B)  => A) ) )  H0)  H0) ) )  var_16)  var_17) .+iff_and :  (A : Uprop ->  (B : Uprop ->  (_220 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (and  ( (dotpipp A)   (_218 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_219 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_10 A)  B)  H)  H) ) ) ) .+iff_to_and :  (A : Uprop ->  (B : Uprop ->  (eprop  ( (iff  ( (iff A)  B) )   ( (and  ( (dotpipp A)   (_243 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_244 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_to_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (iff A)  B) )   (_223 :  (eprop  ( (iff A)  B) )  =>  ( (and  ( (dotpipp A)   (_221 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_222 :  (eprop B)  => A) ) ) ) ) )   ( (dotpipp  ( (and  ( (dotpipp A)   (_224 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_225 :  (eprop B)  => A) ) ) )   (_226 :  (eprop  ( (and  ( (dotpipp A)   (_224 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_225 :  (eprop B)  => A) ) ) )  =>  ( (iff A)  B) ) ) )   (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_227 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_228 :  (eprop B)  => A) ) )   ( (and  ( (dotpipp A)   (_229 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_230 :  (eprop B)  => A) ) ) )   (H0 :  (eprop  ( (dotpipp A)   (_234 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_233 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_231 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_232 :  (eprop B)  => A) ) )   (H0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H00 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H0) ) ) )   (H0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H10 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H0) ) ) ) ) ) )  H) ) )   (H :  (eprop  ( (and  ( (dotpipp A)   (_241 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_242 :  (eprop B)  => A) ) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_235 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_236 :  (eprop B)  => A) ) )   ( (iff A)  B) )   (H0 :  (eprop  ( (dotpipp A)   (_240 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_239 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_237 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_238 :  (eprop B)  => A) ) )   (H0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H00 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H0) ) ) )   (H0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H10 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H0) ) ) ) ) ) )  H) ) ) ) ) .
+ t/bug.eu view
@@ -0,0 +1,5 @@+nat : Type.++x : nat.++y : x.
+ t/coc.eu view
@@ -0,0 +1,28 @@+Utype : Type.++Ukind : Type.++etype : Utype -> Type.++ekind : Ukind -> Type.++dottype : Ukind.++dotpi1 : x : Utype -> y : (etype x -> Utype) -> Utype.+dotpi2 : x : Utype -> y : (etype x -> Ukind) -> Ukind.+dotpi3 : x : Ukind -> y : (ekind x -> Utype) -> Utype.+dotpi4 : x : Ukind -> y : (ekind x -> Ukind) -> Ukind.++[x:Utype, y : etype x -> Utype]+    etype (dotpi1 x y) --> w : etype x -> etype (y w).+[x:Ukind, y : ekind x -> Utype]+    etype (dotpi3 x y) --> w : ekind x -> etype (y w).++[] ekind dottype --> Utype.+[x:Utype, y : etype x -> Ukind]+    ekind (dotpi2 x y) --> w : etype x -> ekind (y w).+[x:Ukind, y : ekind x -> Ukind]+    ekind (dotpi4 x y) --> w : ekind x -> ekind (y w).++a : x : Utype -> y : etype x -> etype x.+[] a --> x : Utype => y : etype x => y.
+ t/conj.eu view
@@ -0,0 +1,3 @@+o : Type.+conj : o -> o -> Type.+[x : o] conj x x --> conj x x.
+ t/coqlogicprel.eu view
@@ -0,0 +1,156 @@+Uset : Type.+Uprop : Type.+Utype : Type.++eprop : x : Uprop -> Type.+eset : x : Uset -> Type.+etype : x : Utype -> Type.++dotset : Utype.+dotprop : Utype.++; /!\ type : type /!\, should use universes+dottype : Utype.++; /!\ subtyping in coq, should be unidirectional /!\+[] Uprop --> Utype.+[] Uset --> Utype.++dotpipp : x : Uprop -> y : (eprop x -> Uprop) -> Uprop.+dotpips : x : Uprop -> y : (eprop x -> Uset)  -> Uset.+dotpipt : x : Uprop -> y : (eprop x -> Utype) -> Utype.+dotpisp : x : Uset  -> y : (eset x  -> Uprop) -> Uprop.+dotpitp : x : Utype -> y : (etype x -> Uprop) -> Uprop.+dotpist : x : Uset  -> y : (eset  x -> Utype) -> Utype.+dotpits : x : Utype -> y : (etype x -> Uset)  -> Uset.+dotpiss : x : Uset  -> y : (eset x  -> Uset)  -> Uset.+dotpitt : x : Utype -> y : (etype x -> Utype) -> Utype.+++[x:Uprop, y : eprop x -> Uprop]+              eprop (dotpipp x y) --> w : eprop x -> eprop (y w).++[x:Uset, y : eset x -> Uprop]+              eprop (dotpisp x y) --> w : eset x -> eprop (y w).++[x:Utype, y : etype x -> Uprop]+              eprop (dotpitp x y) --> w : etype x -> eprop (y w).++; /!\+[P : Uprop] eprop P --> etype P.++[x:Uprop, y : eprop x -> Uset]+              eset (dotpips x y) --> w : eprop x -> eset (y w).++[x:Utype, y : etype x -> Uset]+              eset (dotpits x y) --> w : etype x -> eset (y w).++[x:Uset, y : eset x -> Uset]+              eset (dotpiss x y) --> w : eset x -> eset (y w).++; /!\+[P : Uset] eset P --> etype P.++[x:Uset, y : eset x -> Utype]+              etype (dotpist x y) --> w : eset x -> etype (y w).++[x:Utype, y : etype x -> Utype]+              etype (dotpitt x y) --> w : etype x -> etype (y w).++[x:Uprop, y : eprop x -> Utype]+              etype (dotpipt x y) --> w : eprop x -> etype (y w).+++[] (etype dotset)  --> Uset.+[] (etype dotprop) --> Uprop.+; /!\+[] (etype dottype) --> Utype.++; end of Coq1univ++True : Uprop.+I :  (eprop True) .+case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (_0 :  (eprop True)  ->  (etype P) ) ) ) ) .+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( ( (case_0 P)  f)  t)  I)  --> f.+True_rect :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (etype P) ) ) ) .+[] True_rect -->  (P :  (etype dottype)  =>  (f :  (etype P)  =>  (t :  (eprop True)  =>  ( ( ( (case_0 P)  f)  t)  t) ) ) ) .+True_ind :  (P : Uprop ->  (f :  (eprop P)  ->  (t :  (eprop True)  ->  (eprop P) ) ) ) .+[] True_ind -->  (P :  (etype dotprop)  =>  (True_rect P) ) .+True_rec :  (P : Uset ->  (f :  (eset P)  ->  (t :  (eprop True)  ->  (eset P) ) ) ) .+[] True_rec -->  (P :  (etype dotset)  =>  (True_rect P) ) .+False : Uprop.+case_1 :  (P : Utype ->  (f :  (eprop False)  ->  (_1 :  (eprop False)  ->  (etype P) ) ) ) .+False_rect :  (P : Utype ->  (f :  (eprop False)  ->  (etype P) ) ) .+[] False_rect -->  (P :  (etype dottype)  =>  (f :  (eprop False)  =>  ( ( (case_1 P)  f)  f) ) ) .+False_ind :  (P : Uprop ->  (f :  (eprop False)  ->  (eprop P) ) ) .+[] False_ind -->  (P :  (etype dotprop)  =>  (False_rect P) ) .+False_rec :  (P : Uset ->  (f :  (eprop False)  ->  (eset P) ) ) .+[] False_rec -->  (P :  (etype dotset)  =>  (False_rect P) ) .+not :  (A : Uprop -> Uprop) .+[] not -->  (A :  (etype dotprop)  =>  ( (dotpipp A)   (_2 :  (eprop A)  => False) ) ) .+and :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+conj :  (A : Uprop ->  (B : Uprop ->  (_4 :  (eprop A)  ->  (_3 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) .+case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_6 :  (eprop A)  ->  (_5 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_7 :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Utype, f :  (_9 :  (eprop A)  ->  (_8 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) , var_0 :  (eprop A) , var_1 :  (eprop B) ]  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)   ( ( ( (conj A)  B)  var_0)  var_1) )  -->  ( (f var_0)  var_1) .+and_rect :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_13 :  (eprop A)  ->  (_12 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) .+[] and_rect -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dottype)  =>  (f :  (etype  ( (dotpipt A)   (_11 :  (eprop A)  =>  ( (dotpipt B)   (_10 :  (eprop B)  => P) ) ) ) )  =>  (a :  (eprop  ( (and A)  B) )  =>  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)  a) ) ) ) ) ) .+and_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_15 :  (eprop A)  ->  (_14 :  (eprop B)  ->  (eprop P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eprop P) ) ) ) ) ) .+[] and_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+and_rec :  (A : Uprop ->  (B : Uprop ->  (P : Uset ->  (f :  (_17 :  (eprop A)  ->  (_16 :  (eprop B)  ->  (eset P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eset P) ) ) ) ) ) .+[] and_rec -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotset)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_18 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_2 :  (eprop A) , var_3 :  (eprop B) ]  ( ( ( (case_3 A)  B)  H)   ( ( ( (conj A)  B)  var_2)  var_3) )  -->  ( ( (H0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_2)  var_3) .+proj1 :  (A : Uprop ->  (B : Uprop ->  (_19 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) .+[] proj1 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_3 A)  B)  H)  H) ) ) ) .+case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_20 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_4 :  (eprop A) , var_5 :  (eprop B) ]  ( ( ( (case_4 A)  B)  H)   ( ( ( (conj A)  B)  var_4)  var_5) )  -->  ( ( (H0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_4)  var_5) .+proj2 :  (A : Uprop ->  (B : Uprop ->  (_21 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) .+[] proj2 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_4 A)  B)  H)  H) ) ) ) .+or :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+or_introl :  (A : Uprop ->  (B : Uprop ->  (_22 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) .+or_intror :  (A : Uprop ->  (B : Uprop ->  (_23 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) .+case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_24 :  (eprop A)  ->  (eprop P) )  ->  (f0 :  (_25 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_26 :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_27 :  (eprop A)  ->  (eprop P) ) , f0 :  (_28 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_6 :  (eprop A) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)   ( ( (or_introl A)  B)  var_6) )  -->  (f var_6) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_27 :  (eprop A)  ->  (eprop P) ) , f0 :  (_28 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_7 :  (eprop B) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)   ( ( (or_intror A)  B)  var_7) )  -->  (f0 var_7) .+or_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_31 :  (eprop A)  ->  (eprop P) )  ->  (f0 :  (_32 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) .+[] or_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpipp A)   (_30 :  (eprop A)  => P) ) )  =>  (f0 :  (eprop  ( (dotpipp B)   (_29 :  (eprop B)  => P) ) )  =>  (o :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f0)  o)  o) ) ) ) ) ) ) .+iff :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+[] iff -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( (and  ( (dotpipp A)   (_33 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_34 :  (eprop B)  => A) ) ) ) ) .+iff_refl :  (A : Uprop ->  (eprop  ( (iff A)  A) ) ) .+[] iff_refl -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp A)   (_35 :  (eprop A)  => A) ) )   ( (dotpipp A)   (_36 :  (eprop A)  => A) ) )   (H :  (eprop A)  => H) )   (H :  (eprop A)  => H) ) ) .+case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_40 :  (eprop  ( (and  ( (dotpipp A)   (_37 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_38 :  (eprop B)  => A) ) ) )  ->  (_39 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) .+case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_41 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_42 :  (eprop B)  ->  (eprop A) )  ->  (H0 :  (eprop  ( (iff B)  C) )  ->  (_45 :  (eprop  ( (and  ( (dotpipp B)   (_43 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_44 :  (eprop C)  => B) ) ) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_46 :  (eprop A)  ->  (eprop B) ) , H2 :  (_47 :  (eprop B)  ->  (eprop A) ) , H0 :  (eprop  ( (iff B)  C) ) , var_10 :  (eprop B) , var_11 :  (eprop C) ]  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H0)   ( ( ( (conj B)  C)  var_10)  var_11) )  -->  ( ( (H3 :  (eprop  ( (dotpipp B)   (_51 :  (eprop B)  => C) ) )  =>  (H4 :  (eprop  ( (dotpipp C)   (_50 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_48 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_49 :  (eprop C)  => A) ) )   (H1 :  (eprop A)  =>  (H3  (H1 H1) ) ) )   (H1 :  (eprop C)  =>  (H2  (H1  (H2  (H4 H1) ) ) ) ) ) ) )  var_10)  var_11) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , var_8 :  (eprop A) , var_9 :  (eprop B) ]  ( ( ( ( (case_6 A)  B)  C)  H)   ( ( ( (conj A)  B)  var_8)  var_9) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_53 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_52 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H0)  H0) ) ) )  var_8)  var_9) .+iff_trans :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_55 :  (eprop  ( (iff A)  B) )  ->  (_54 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) .+[] iff_trans -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (case_6 A)  B)  C)  H)  H) ) ) ) ) .+case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_58 :  (eprop  ( (and  ( (dotpipp A)   (_56 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_57 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (iff B)  A) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_12 :  (eprop A) , var_13 :  (eprop B) ]  ( ( ( (case_8 A)  B)  H)   ( ( ( (conj A)  B)  var_12)  var_13) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_62 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_61 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_59 :  (eprop B)  => A) ) )   ( (dotpipp A)   (_60 :  (eprop A)  => B) ) )  H2)  H1) ) )  var_12)  var_13) .+iff_sym :  (A : Uprop ->  (B : Uprop ->  (_63 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (iff B)  A) ) ) ) ) .+[] iff_sym -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_8 A)  B)  H)  H) ) ) ) .+case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_74 :  (eprop  ( (and  ( (dotpipp A)   (_71 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_72 :  (eprop False)  => A) ) ) )  ->  (_73 :  (eprop A)  ->  (eprop False) ) ) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) , var_14 :  (eprop A) , var_15 :  (eprop False) ]  ( ( (case_9 A)  H)   ( ( ( (conj A)  False)  var_14)  var_15) )  -->  ( ( (H0 :  (eprop  ( (dotpipp A)   (_76 :  (eprop A)  => False) ) )  =>  (H0 :  (eprop  ( (dotpipp False)   (_75 :  (eprop False)  => A) ) )  => H0) )  var_14)  var_15) .+neg_false :  (A : Uprop ->  (eprop  ( (iff  (not A) )   ( (iff A)  False) ) ) ) .+[] neg_false -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (dotpipp A)   (_64 :  (eprop A)  => False) ) )   (_65 :  (eprop  ( (dotpipp A)   (_64 :  (eprop A)  => False) ) )  =>  ( (iff A)  False) ) ) )   ( (dotpipp  ( (iff A)  False) )   (_67 :  (eprop  ( (iff A)  False) )  =>  ( (dotpipp A)   (_66 :  (eprop A)  => False) ) ) ) )   (H :  (eprop  ( (dotpipp A)   (_70 :  (eprop A)  => False) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_68 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_69 :  (eprop False)  => A) ) )  H)   (H1 :  (eprop False)  =>  ( (False_ind A)  H1) ) ) ) )   (H :  (eprop  ( (iff A)  False) )  =>  ( ( (case_9 A)  H)  H) ) ) ) .+and_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_104 :  (_101 :  (eprop B)  ->  (eprop A) )  ->  (_103 :  (_102 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_100 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_99 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (_77 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_78 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and A)  B) )   (_79 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_80 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and A)  B) )   (_92 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and A)  C) )   (_91 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp A)   (_90 :  (eprop A)  =>  ( (dotpipp B)   (_89 :  (eprop B)  =>  ( (and A)  C) ) ) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp A)   (_88 :  (eprop A)  =>  ( (dotpipp C)   (_87 :  (eprop C)  =>  ( (and A)  B) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_81 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_82 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp B)   (_84 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H11 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  C)   (H1 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H12 :  (eprop  ( (dotpipp C)   (_83 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H21 :  (eprop A)  =>  ( (H00 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  C)   (H13 :  (eprop A)  =>  (H6 :  (eprop B)  => H5) ) )  H00) )   (H12 H5) ) )   (H0 H5) ) )   (H20 H4) ) ) ) )  H11) )   (H0 H30) ) )   (H10 H4) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp B)   (_86 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H11 :  (eprop  ( (dotpipp C)   (_85 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H21 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  B)   (H12 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H22 :  (eprop A)  =>  ( (H0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  B)   (H01 :  (eprop A)  =>  (H6 :  (eprop C)  => H5) ) )  H0) )   (H00 H5) ) )   (H H5) ) ) ) )  H21) )   (H11 H30) ) )   (H20 H4) ) )   (H10 H4) ) )   (H0 H30) ) ) ) )   (H20 :  (eprop A)  =>  (H4 :  (eprop C)  =>  (H3  ( ( ( (conj A)  C)  H20)  H4) ) ) ) ) )   (H10 :  (eprop A)  =>  (H4 :  (eprop B)  =>  (H2  ( ( ( (conj A)  B)  H10)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_93 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_94 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_98 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_97 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_95 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_96 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H10 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H4 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H11 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj A)  C)  H20)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H5) ) )   (H H5) ) ) ) )  H10) ) )   (H10 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H4 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H11 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H30)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H5) ) )   (H0 H5) ) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_132 :  (_129 :  (eprop B)  ->  (eprop A) )  ->  (_131 :  (_130 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_128 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_127 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (_105 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_106 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and B)  A) )   (_107 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_108 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and B)  A) )   (_120 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and C)  A) )   (_119 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp B)   (_118 :  (eprop B)  =>  ( (dotpipp A)   (_117 :  (eprop A)  =>  ( (and C)  A) ) ) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp C)   (_116 :  (eprop C)  =>  ( (dotpipp A)   (_115 :  (eprop A)  =>  ( (and B)  A) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_109 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_110 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp A)   (_112 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H11 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  C)   (H1 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H12 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp A)   (_111 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H21 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  C)   (H01 :  (eprop B)  =>  (H6 :  (eprop A)  => H1) ) )  H21) )   (H00 H4) ) )   (H20 H1) ) )   (H0 H1) ) ) ) )  H11) )   (H0 H4) ) )   (H10 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H00 :  (eprop  ( (dotpipp A)   (_114 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H21 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  B)   (H01 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H22 :  (eprop A)  =>  ( (H0 :  (eprop  ( (dotpipp A)   (_113 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H11 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  B)   (H1 :  (eprop C)  =>  (H6 :  (eprop A)  => H01) ) )  H11) )   (H0 H4) ) )   (H10 H01) ) )   (H H01) ) ) ) )  H21) )   (H00 H4) ) )   (H20 H30) ) )   (H0 H30) ) ) ) )   (H20 :  (eprop C)  =>  (H4 :  (eprop A)  =>  (H3  ( ( ( (conj C)  A)  H20)  H4) ) ) ) ) )   (H10 :  (eprop B)  =>  (H4 :  (eprop A)  =>  (H2  ( ( ( (conj B)  A)  H10)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_121 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_122 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_126 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_125 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_123 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_124 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H10 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H4 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H11 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj C)  A)  H0)  H20) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) ) )  H10) ) )   (H10 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H4 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H11 :  (eprop A)  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop A)  =>  ( (H0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H00)  H30) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_156 :  (_153 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_155 :  (_154 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_152 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_151 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (_133 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_134 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or A)  B) )   (_135 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_136 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or A)  B) )   (_144 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or A)  C) )   (_143 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp A)   (_142 :  (eprop A)  =>  ( (or A)  C) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp B)   (_141 :  (eprop B)  =>  ( (or A)  C) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp A)   (_140 :  (eprop A)  =>  ( (or A)  B) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp C)   (_139 :  (eprop C)  =>  ( (or A)  B) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_137 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_138 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H40 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H11 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )   (H11 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (False_ind C)  H00) ) )   (H50 :  (eprop B)  =>  ( (False_ind C)  H00) ) )  H61) )   (H5 H11) ) )   (H60 H40) ) )   (H0 H11) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (False_ind C)  H00) ) )   (H50 :  (eprop B)  =>  ( (False_ind C)  H00) ) )  H61) )   (H5 H11) ) )   (H60 H40) ) )   (H0 H11) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )  H1) )   (H10 H40) ) ) )   (H40 :  (eprop C)  =>  ( (H1 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H50 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H11 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )   (H11 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H50) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )  H01) )   (H10 H50) ) ) )   (H50 :  (eprop B)  => H40) )  H00) )   (H5 H40) ) )   (H0 H40) ) ) )  H0) )   (H4 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H50 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H11 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (False_ind B)  H0) ) )   (H40 :  (eprop C)  =>  ( (False_ind B)  H0) ) )  H61) )   (H4 H21) ) )   (H60 H50) ) )   (H H21) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )   (H11 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H50) ) ) )   (H21 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (False_ind B)  H0) ) )   (H40 :  (eprop C)  =>  ( (False_ind B)  H0) ) )  H61) )   (H4 H21) ) )   (H60 H50) ) )   (H H21) ) )   (H6 H50) ) ) )  H02) )   (H20 H50) ) ) )  H01) )   (H10 H50) ) ) )   (H50 :  (eprop B)  =>  ( (H01 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H40 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H11 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )   (H11 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H21 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )   (H21 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H40) ) )   (H6 H40) ) ) )  H2) )   (H20 H40) ) ) )  H1) )   (H10 H40) ) ) )   (H40 :  (eprop C)  => H50) )  H0) )   (H4 H50) ) )   (H H50) ) ) )  H00) )   (H5 H30) ) )   (H0 H30) ) ) ) )   (H5 :  (eprop C)  =>  (H3  ( ( (or_intror A)  C)  H5) ) ) ) )   (H20 :  (eprop A)  =>  (H3  ( ( (or_introl A)  C)  H20) ) ) ) )   (H4 :  (eprop B)  =>  (H2  ( ( (or_intror A)  B)  H4) ) ) ) )   (H10 :  (eprop A)  =>  (H2  ( ( (or_introl A)  B)  H10) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_145 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_146 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_150 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_149 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_147 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_148 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H10 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  C)  H4) ) )   (H4 :  (eprop B)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( ( (or_intror A)  C)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) )  H10) ) )   (H10 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  B)  H4) ) )   (H4 :  (eprop C)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_180 :  (_177 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_179 :  (_178 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_176 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_175 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (_157 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_158 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or B)  A) )   (_159 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_160 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or B)  A) )   (_168 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or C)  A) )   (_167 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )  =>  ( (H10 :  (eprop  ( (dotpipp B)   (_166 :  (eprop B)  =>  ( (or C)  A) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp A)   (_165 :  (eprop A)  =>  ( (or C)  A) ) ) )  =>  ( (H20 :  (eprop  ( (dotpipp C)   (_164 :  (eprop C)  =>  ( (or B)  A) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp A)   (_163 :  (eprop A)  =>  ( (or B)  A) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_161 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_162 :  (eprop C)  => B) ) )   (H30 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H11 :  (eprop C)  =>  ( (H1 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  => H11) )   (H21 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H40 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )   (H40 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind C)  H60) )   (H1 H21) ) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )  H01) )   (H4 H21) ) ) )  H00) )   (H20 H11) ) )   (H0 H11) ) ) )   (H11 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H40 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  =>  ( (False_ind C)  H00) ) )   (H21 :  (eprop A)  =>  ( (False_ind C)  H00) ) )  H61) )   (H20 H40) ) )   (H60 H11) ) )   (H0 H40) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H00 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H21 :  (eprop B)  =>  ( (False_ind C)  H00) ) )   (H21 :  (eprop A)  =>  ( (False_ind C)  H00) ) )  H61) )   (H20 H40) ) )   (H60 H11) ) )   (H0 H40) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )   (H40 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (False_ind C)  H3) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )  H1) )   (H4 H11) ) ) )  H0) )   (H10 H30) ) )   (H H30) ) ) )   (H30 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H00 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H21 :  (eprop B)  =>  ( (H01 :  (eprop  (not A) )  =>  ( (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  => H21) )   (H11 :  (eprop A)  =>  ( (H1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H40 :  (eprop C)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )   (H40 :  (eprop A)  =>  ( (H2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )   (H50 :  (eprop A)  =>  ( (H3 :  (eprop False)  =>  ( (H60 :  (eprop False)  =>  ( (False_ind B)  H60) )   (H01 H11) ) )   (H6 H11) ) ) )  H2) )   (H5 H11) ) ) )  H1) )   (H4 H11) ) ) )  H0) )   (H10 H21) ) )   (H H21) ) ) )   (H21 :  (eprop A)  =>  ( (H01 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H40 :  (eprop C)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  =>  ( (False_ind B)  H0) ) )   (H11 :  (eprop A)  =>  ( (False_ind B)  H0) ) )  H61) )   (H10 H50) ) )   (H60 H21) ) )   (H H50) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )   (H40 :  (eprop A)  =>  ( (H02 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H50 :  (eprop B)  =>  ( (H03 :  (eprop False)  =>  ( (H60 :  (eprop  (not A) )  =>  ( (H0 :  (eprop False)  =>  ( (H61 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H11 :  (eprop C)  =>  ( (False_ind B)  H0) ) )   (H11 :  (eprop A)  =>  ( (False_ind B)  H0) ) )  H61) )   (H10 H50) ) )   (H60 H21) ) )   (H H50) ) )   (H6 H21) ) ) )   (H50 :  (eprop A)  =>  ( (H03 :  (eprop False)  =>  ( (False_ind B)  H03) )   (H6 H21) ) ) )  H02) )   (H5 H21) ) ) )  H01) )   (H4 H21) ) ) )  H00) )   (H20 H30) ) )   (H0 H30) ) ) ) )   (H5 :  (eprop A)  =>  (H3  ( ( (or_intror C)  A)  H5) ) ) ) )   (H20 :  (eprop C)  =>  (H3  ( ( (or_introl C)  A)  H20) ) ) ) )   (H4 :  (eprop A)  =>  (H2  ( ( (or_intror B)  A)  H4) ) ) ) )   (H10 :  (eprop B)  =>  (H2  ( ( (or_introl B)  A)  H10) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_169 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_170 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_174 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_173 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_171 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_172 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H10 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H4 :  (eprop B)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( (H20 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( ( (or_introl C)  A)  H0) )   (H3 H0) ) )   (H0 H0) ) )   (H2 H4) ) )   (H H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror C)  A)  H4) ) )  H10) ) )   (H10 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H4 :  (eprop C)  =>  ( (H11 :  (eprop  (not A) )  =>  ( (H00 :  (eprop B)  =>  ( (H30 :  (eprop  (not A) )  =>  ( (H0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H00) )   (H2 H00) ) )   (H H00) ) )   (H3 H4) ) )   (H0 H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror B)  A)  H4) ) )  H10) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_187 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) ) ) ) .+[] and_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_181 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_182 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_186 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_185 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_183 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_184 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H2 :  (eprop A)  =>  (H3 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2)  H1) )   (H1 H1) ) )   (H0 H3) ) ) ) )  H0) ) )   (H0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H2 :  (eprop A)  =>  (H3 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( ( (conj A)  B)  H2)  H1) )   (H0 H1) ) )   (H1 H3) ) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+and_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_194 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) ) ) ) .+[] and_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_188 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_189 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_193 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_192 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_190 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_191 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H2 :  (eprop B)  =>  (H3 :  (eprop A)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( ( (conj C)  A)  H1)  H3) )   (H1 H1) ) )   (H0 H2) ) ) ) )  H0) ) )   (H0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H2 :  (eprop C)  =>  (H3 :  (eprop A)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( ( (conj B)  A)  H1)  H3) )   (H0 H1) ) )   (H1 H2) ) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_201 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) ) ) ) .+[] or_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_195 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_196 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_200 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_199 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_197 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_198 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  C)  H2) ) )   (H2 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( (or_intror A)  C)  H1) )   (H1 H1) ) )   (H0 H2) ) ) )  H0) ) )   (H0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  B)  H2) ) )   (H2 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( (or_intror A)  B)  H1) )   (H0 H1) ) )   (H1 H2) ) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_208 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) ) ) ) .+[] or_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_202 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_203 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_207 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_206 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_204 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_205 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H2 :  (eprop B)  =>  ( (H1 :  (eprop C)  =>  ( (H00 :  (eprop B)  =>  ( ( (or_introl C)  A)  H1) )   (H1 H1) ) )   (H0 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror C)  A)  H2) ) )  H0) ) )   (H0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H2 :  (eprop C)  =>  ( (H1 :  (eprop B)  =>  ( (H10 :  (eprop C)  =>  ( ( (or_introl B)  A)  H1) )   (H0 H1) ) )   (H1 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror B)  A)  H2) ) )  H0) ) ) ) ) )  H) ) ) ) ) .+case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_213 :  (eprop  ( (and  ( (dotpipp A)   (_209 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_210 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (and  ( (dotpipp A)   (_211 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_212 :  (eprop B)  => A) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_16 :  (eprop A) , var_17 :  (eprop B) ]  ( ( ( (case_10 A)  B)  H)   ( ( ( (conj A)  B)  var_16)  var_17) )  -->  ( ( (H0 :  (eprop  ( (dotpipp A)   (_217 :  (eprop A)  => B) ) )  =>  (H0 :  (eprop  ( (dotpipp B)   (_216 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_214 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_215 :  (eprop B)  => A) ) )  H0)  H0) ) )  var_16)  var_17) .+iff_and :  (A : Uprop ->  (B : Uprop ->  (_220 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (and  ( (dotpipp A)   (_218 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_219 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_10 A)  B)  H)  H) ) ) ) .+iff_to_and :  (A : Uprop ->  (B : Uprop ->  (eprop  ( (iff  ( (iff A)  B) )   ( (and  ( (dotpipp A)   (_243 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_244 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_to_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (iff A)  B) )   (_223 :  (eprop  ( (iff A)  B) )  =>  ( (and  ( (dotpipp A)   (_221 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_222 :  (eprop B)  => A) ) ) ) ) )   ( (dotpipp  ( (and  ( (dotpipp A)   (_224 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_225 :  (eprop B)  => A) ) ) )   (_226 :  (eprop  ( (and  ( (dotpipp A)   (_224 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_225 :  (eprop B)  => A) ) ) )  =>  ( (iff A)  B) ) ) )   (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_227 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_228 :  (eprop B)  => A) ) )   ( (and  ( (dotpipp A)   (_229 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_230 :  (eprop B)  => A) ) ) )   (H0 :  (eprop  ( (dotpipp A)   (_234 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_233 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_231 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_232 :  (eprop B)  => A) ) )   (H0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H00 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H0) ) ) )   (H0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H10 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H0) ) ) ) ) ) )  H) ) )   (H :  (eprop  ( (and  ( (dotpipp A)   (_241 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_242 :  (eprop B)  => A) ) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_235 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_236 :  (eprop B)  => A) ) )   ( (iff A)  B) )   (H0 :  (eprop  ( (dotpipp A)   (_240 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_239 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_237 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_238 :  (eprop B)  => A) ) )   (H0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H00 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H0) ) ) )   (H0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H10 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H0) ) ) ) ) ) )  H) ) ) ) ) .
+ t/delta1.eu view
@@ -0,0 +1,2 @@+delta : a : Type -> (b : Type -> b -> b) -> a -> a.+[] delta --> a : Type => x : (Type -> Type) => x (a -> a) (x a).
+ t/delta2.eu view
@@ -0,0 +1,7 @@+;; Same as delta1.eu but with d2 declared of type 'delta delta', which of+;; course is ill-typed.++delta : a : Type -> (b : Type -> b -> b) -> a -> a.+[] delta --> a : Type => x : (Type -> Type) => x (a -> a) (x a).++d2 : delta delta.
+ t/exemple.eu view
@@ -0,0 +1,9 @@+T : Type.++U : Type.++[] U --> T -> T.++app : f : (T -> T) -> T -> T.++[] app --> f : U => x : T => f x.
+ t/f.eu view
@@ -0,0 +1,17 @@+Utype : Type.+Ukind : Type.+etype : Utype -> Type.+ekind : Ukind -> Type.+dottype : Ukind.+dotpi1 : x : Utype -> (etype x -> Utype) -> Utype.+dotpi3 : x : Ukind -> (ekind x -> Utype) -> Utype.+[] ekind dottype --> Utype.+[x:Utype, y : etype x -> Utype]+                  etype ((dotpi1 x) y) --> w : etype x -> etype (y w).++[x:Ukind, y : ekind x -> Utype]+                  etype ((dotpi3 x) y) --> w : ekind x -> etype (y w).++a : x : Utype -> etype x -> etype x.++[] a --> x : Utype => y : etype x => y.
+ t/gros.eu view
@@ -0,0 +1,360 @@+Uset : Type.+Uprop : Type.+Utype : Type.++eprop : x : Uprop -> Type.+eset : x : Uset -> Type.+etype : x : Utype -> Type.++dotset : Utype.+dotprop : Utype.++; /!\ type : type /!\, should use universes+dottype : Utype.++; /!\ subtyping in coq, should be unidirectional /!\+[] Uprop --> Utype.+[] Uset --> Utype.++dotpipp : x : Uprop -> y : (eprop x -> Uprop) -> Uprop.+dotpips : x : Uprop -> y : (eprop x -> Uset)  -> Uset.+dotpipt : x : Uprop -> y : (eprop x -> Utype) -> Utype.+dotpisp : x : Uset  -> y : (eset x  -> Uprop) -> Uprop.+dotpitp : x : Utype -> y : (etype x -> Uprop) -> Uprop.+dotpist : x : Uset  -> y : (eset  x -> Utype) -> Utype.+dotpits : x : Utype -> y : (etype x -> Uset)  -> Uset.+dotpiss : x : Uset  -> y : (eset x  -> Uset)  -> Uset.+dotpitt : x : Utype -> y : (etype x -> Utype) -> Utype.+++[x:Uprop, y : eprop x -> Uprop]+              eprop (dotpipp x y) --> w : eprop x -> eprop (y w).++[x:Uset, y : eset x -> Uprop]+              eprop (dotpisp x y) --> w : eset x -> eprop (y w).++[x:Utype, y : etype x -> Uprop]+              eprop (dotpitp x y) --> w : etype x -> eprop (y w).++; /!\+[P : Uprop] eprop P --> etype P.++[x:Uprop, y : eprop x -> Uset]+              eset (dotpips x y) --> w : eprop x -> eset (y w).++[x:Utype, y : etype x -> Uset]+              eset (dotpits x y) --> w : etype x -> eset (y w).++[x:Uset, y : eset x -> Uset]+              eset (dotpiss x y) --> w : eset x -> eset (y w).++; /!\+[P : Uset] eset P --> etype P.++[x:Uset, y : eset x -> Utype]+              etype (dotpist x y) --> w : eset x -> etype (y w).++[x:Utype, y : etype x -> Utype]+              etype (dotpitt x y) --> w : etype x -> etype (y w).++[x:Uprop, y : eprop x -> Utype]+              etype (dotpipt x y) --> w : eprop x -> etype (y w).+++[] (etype dotset)  --> Uset.+[] (etype dotprop) --> Uprop.+; /!\+[] (etype dottype) --> Utype.++; end of Coq1univ++True : Uprop.+I :  (eprop True) .+case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (_0 :  (eprop True)  ->  (etype P) ) ) ) ) .+I_case_0 :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (eprop True) ) ) ) .+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( (I_case_0 P)  f)  t)  --> I.+[P : Utype, f :  (etype P) , t :  (eprop True) ]  ( ( ( (case_0 P)  f)  t)   ( ( (I_case_0 P)  f)  t) )  --> f.+True_rect :  (P : Utype ->  (f :  (etype P)  ->  (t :  (eprop True)  ->  (etype P) ) ) ) .+[] True_rect -->  (P :  (etype dottype)  =>  (f :  (etype P)  =>  (t :  (eprop True)  =>  ( ( ( (case_0 P)  f)  t)  t) ) ) ) .+True_ind :  (P : Uprop ->  (f :  (eprop P)  ->  (t :  (eprop True)  ->  (eprop P) ) ) ) .+[] True_ind -->  (P :  (etype dotprop)  =>  (True_rect P) ) .+True_rec :  (P : Uset ->  (f :  (eset P)  ->  (t :  (eprop True)  ->  (eset P) ) ) ) .+[] True_rec -->  (P :  (etype dotset)  =>  (True_rect P) ) .+False : Uprop.+case_1 :  (P : Utype ->  (f :  (eprop False)  ->  (_1 :  (eprop False)  ->  (etype P) ) ) ) .+False_rect :  (P : Utype ->  (f :  (eprop False)  ->  (etype P) ) ) .+[] False_rect -->  (P :  (etype dottype)  =>  (f :  (eprop False)  =>  ( ( (case_1 P)  f)  f) ) ) .+False_ind :  (P : Uprop ->  (f :  (eprop False)  ->  (eprop P) ) ) .+[] False_ind -->  (P :  (etype dotprop)  =>  (False_rect P) ) .+False_rec :  (P : Uset ->  (f :  (eprop False)  ->  (eset P) ) ) .+[] False_rec -->  (P :  (etype dotset)  =>  (False_rect P) ) .+not :  (A : Uprop -> Uprop) .+[] not -->  (A :  (etype dotprop)  =>  ( (dotpipp A)   (_2 :  (eprop A)  => False) ) ) .+and :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+conj :  (A : Uprop ->  (B : Uprop ->  (_4 :  (eprop A)  ->  (_3 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) .+case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_6 :  (eprop A)  ->  (_5 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_7 :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) ) .+conj_case_2 :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_11 :  (eprop A)  ->  (_10 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (_13 :  (eprop A)  ->  (_12 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Utype, f :  (_15 :  (eprop A)  ->  (_14 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) ]  ( ( ( ( (conj_case_2 A)  B)  P)  f)  a)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, P : Utype, f :  (_9 :  (eprop A)  ->  (_8 :  (eprop B)  ->  (etype P) ) ) , a :  (eprop  ( (and A)  B) ) , var_0 :  (eprop A) , var_1 :  (eprop B) ]  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)   ( ( ( ( ( ( (conj_case_2 A)  B)  P)  f)  a)  var_0)  var_1) )  -->  ( (f var_0)  var_1) .+and_rect :  (A : Uprop ->  (B : Uprop ->  (P : Utype ->  (f :  (_19 :  (eprop A)  ->  (_18 :  (eprop B)  ->  (etype P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (etype P) ) ) ) ) ) .+[] and_rect -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dottype)  =>  (f :  (etype  ( (dotpipt A)   (_17 :  (eprop A)  =>  ( (dotpipt B)   (_16 :  (eprop B)  => P) ) ) ) )  =>  (a :  (eprop  ( (and A)  B) )  =>  ( ( ( ( ( (case_2 A)  B)  P)  f)  a)  a) ) ) ) ) ) .+and_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_21 :  (eprop A)  ->  (_20 :  (eprop B)  ->  (eprop P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eprop P) ) ) ) ) ) .+[] and_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+and_rec :  (A : Uprop ->  (B : Uprop ->  (P : Uset ->  (f :  (_23 :  (eprop A)  ->  (_22 :  (eprop B)  ->  (eset P) ) )  ->  (a :  (eprop  ( (and A)  B) )  ->  (eset P) ) ) ) ) ) .+[] and_rec -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotset)  =>  ( ( (and_rect A)  B)  P) ) ) ) .+case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_24 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) ) .+conj_case_3 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_26 :  (eprop A)  ->  (_25 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) ]  ( ( (conj_case_3 A)  B)  H)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_2 :  (eprop A) , var_3 :  (eprop B) ]  ( ( ( (case_3 A)  B)  H)   ( ( ( ( (conj_case_3 A)  B)  H)  var_2)  var_3) )  -->  ( ( (H欧0 :  (eprop A)  =>  (H0 :  (eprop B)  => H欧0) )  var_2)  var_3) .+proj1 :  (A : Uprop ->  (B : Uprop ->  (_27 :  (eprop  ( (and A)  B) )  ->  (eprop A) ) ) ) .+[] proj1 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_3 A)  B)  H)  H) ) ) ) .+case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_28 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) ) .+conj_case_4 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (and A)  B) )  ->  (_30 :  (eprop A)  ->  (_29 :  (eprop B)  ->  (eprop  ( (and A)  B) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) ]  ( ( (conj_case_4 A)  B)  H)  -->  ( (conj A)  B) .+[A : Uprop, B : Uprop, H :  (eprop  ( (and A)  B) ) , var_4 :  (eprop A) , var_5 :  (eprop B) ]  ( ( ( (case_4 A)  B)  H)   ( ( ( ( (conj_case_4 A)  B)  H)  var_4)  var_5) )  -->  ( ( (H欧0 :  (eprop A)  =>  (H0 :  (eprop B)  => H0) )  var_4)  var_5) .+proj2 :  (A : Uprop ->  (B : Uprop ->  (_31 :  (eprop  ( (and A)  B) )  ->  (eprop B) ) ) ) .+[] proj2 -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (and A)  B) )  =>  ( ( ( (case_4 A)  B)  H)  H) ) ) ) .+or :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+or_introl :  (A : Uprop ->  (B : Uprop ->  (_32 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) .+or_intror :  (A : Uprop ->  (B : Uprop ->  (_33 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) .+case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_34 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_35 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_36 :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) ) .+or_introl_case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_39 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_40 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_41 :  (eprop A)  ->  (eprop  ( (or A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_42 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_43 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) ]  ( ( ( ( ( (or_introl_case_5 A)  B)  P)  f)  f欧0)  o)  -->  ( (or_introl A)  B) .+or_intror_case_5 :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_44 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_45 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (_46 :  (eprop B)  ->  (eprop  ( (or A)  B) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_47 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_48 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) ]  ( ( ( ( ( (or_intror_case_5 A)  B)  P)  f)  f欧0)  o)  -->  ( (or_intror A)  B) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_37 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_38 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_6 :  (eprop A) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)   ( ( ( ( ( ( (or_introl_case_5 A)  B)  P)  f)  f欧0)  o)  var_6) )  -->  (f var_6) .+[A : Uprop, B : Uprop, P : Uprop, f :  (_37 :  (eprop A)  ->  (eprop P) ) , f欧0 :  (_38 :  (eprop B)  ->  (eprop P) ) , o :  (eprop  ( (or A)  B) ) , var_7 :  (eprop B) ]  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)   ( ( ( ( ( ( (or_intror_case_5 A)  B)  P)  f)  f欧0)  o)  var_7) )  -->  (f欧0 var_7) .+or_ind :  (A : Uprop ->  (B : Uprop ->  (P : Uprop ->  (f :  (_51 :  (eprop A)  ->  (eprop P) )  ->  (f欧0 :  (_52 :  (eprop B)  ->  (eprop P) )  ->  (o :  (eprop  ( (or A)  B) )  ->  (eprop P) ) ) ) ) ) ) .+[] or_ind -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpipp A)   (_50 :  (eprop A)  => P) ) )  =>  (f欧0 :  (eprop  ( (dotpipp B)   (_49 :  (eprop B)  => P) ) )  =>  (o :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( ( (case_5 A)  B)  P)  f)  f欧0)  o)  o) ) ) ) ) ) ) .+iff :  (A : Uprop ->  (B : Uprop -> Uprop) ) .+[] iff -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( (and  ( (dotpipp A)   (_53 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_54 :  (eprop B)  => A) ) ) ) ) .+iff_refl :  (A : Uprop ->  (eprop  ( (iff A)  A) ) ) .+[] iff_refl -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp A)   (_55 :  (eprop A)  => A) ) )   ( (dotpipp A)   (_56 :  (eprop A)  => A) ) )   (H :  (eprop A)  => H) )   (H :  (eprop A)  => H) ) ) .+case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_60 :  (eprop  ( (and  ( (dotpipp A)   (_57 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_58 :  (eprop B)  => A) ) ) )  ->  (_59 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) .+conj_case_6 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_68 :  (_63 :  (eprop A)  ->  (eprop B) )  ->  (_67 :  (_64 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_65 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_66 :  (eprop B)  => A) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( ( (conj_case_6 A)  B)  C)  H)  -->  ( (conj  ( (dotpipp A)   (_61 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_62 :  (eprop B)  => A) ) ) .+case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_71 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_72 :  (eprop B)  ->  (eprop A) )  ->  (H欧0 :  (eprop  ( (iff B)  C) )  ->  (_75 :  (eprop  ( (and  ( (dotpipp B)   (_73 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_74 :  (eprop C)  => B) ) ) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) ) ) ) .+conj_case_7 :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (H1 :  (_80 :  (eprop A)  ->  (eprop B) )  ->  (H2 :  (_81 :  (eprop B)  ->  (eprop A) )  ->  (H欧0 :  (eprop  ( (iff B)  C) )  ->  (_87 :  (_82 :  (eprop B)  ->  (eprop C) )  ->  (_86 :  (_83 :  (eprop C)  ->  (eprop B) )  ->  (eprop  ( (and  ( (dotpipp B)   (_84 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_85 :  (eprop C)  => B) ) ) ) ) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_88 :  (eprop A)  ->  (eprop B) ) , H2 :  (_89 :  (eprop B)  ->  (eprop A) ) , H欧0 :  (eprop  ( (iff B)  C) ) ]  ( ( ( ( ( ( (conj_case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  -->  ( (conj  ( (dotpipp B)   (_78 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_79 :  (eprop C)  => B) ) ) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , H1 :  (_76 :  (eprop A)  ->  (eprop B) ) , H2 :  (_77 :  (eprop B)  ->  (eprop A) ) , H欧0 :  (eprop  ( (iff B)  C) ) , var_10 :  (_90 :  (eprop B)  ->  (eprop C) ) , var_11 :  (_91 :  (eprop C)  ->  (eprop B) ) ]  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H欧0)   ( ( ( ( ( ( ( ( (conj_case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  var_10)  var_11) )  -->  ( ( (H3 :  (eprop  ( (dotpipp B)   (_95 :  (eprop B)  => C) ) )  =>  (H4 :  (eprop  ( (dotpipp C)   (_94 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_92 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_93 :  (eprop C)  => A) ) )   (H欧1 :  (eprop A)  =>  (H3  (H1 H欧1) ) ) )   (H欧1 :  (eprop C)  =>  (H2  (H1  (H2  (H4 H欧1) ) ) ) ) ) ) )  var_10)  var_11) .+[A : Uprop, B : Uprop, C : Uprop, H :  (eprop  ( (iff A)  B) ) , var_8 :  (_69 :  (eprop A)  ->  (eprop B) ) , var_9 :  (_70 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( ( (case_6 A)  B)  C)  H)   ( ( ( ( ( (conj_case_6 A)  B)  C)  H)  var_8)  var_9) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_97 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_96 :  (eprop B)  => A) ) )  =>  (H欧0 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( ( ( ( (case_7 A)  B)  C)  H)  H1)  H2)  H欧0)  H欧0) ) ) )  var_8)  var_9) .+iff_trans :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_99 :  (eprop  ( (iff A)  B) )  ->  (_98 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff A)  C) ) ) ) ) ) ) .+[] iff_trans -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (case_6 A)  B)  C)  H)  H) ) ) ) ) .+case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_102 :  (eprop  ( (and  ( (dotpipp A)   (_100 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_101 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (iff B)  A) ) ) ) ) ) .+conj_case_8 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_110 :  (_105 :  (eprop A)  ->  (eprop B) )  ->  (_109 :  (_106 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_107 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_108 :  (eprop B)  => A) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( (conj_case_8 A)  B)  H)  -->  ( (conj  ( (dotpipp A)   (_103 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_104 :  (eprop B)  => A) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_12 :  (_111 :  (eprop A)  ->  (eprop B) ) , var_13 :  (_112 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( (case_8 A)  B)  H)   ( ( ( ( (conj_case_8 A)  B)  H)  var_12)  var_13) )  -->  ( ( (H1 :  (eprop  ( (dotpipp A)   (_116 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_115 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_113 :  (eprop B)  => A) ) )   ( (dotpipp A)   (_114 :  (eprop A)  => B) ) )  H2)  H1) ) )  var_12)  var_13) .+iff_sym :  (A : Uprop ->  (B : Uprop ->  (_117 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (iff B)  A) ) ) ) ) .+[] iff_sym -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_8 A)  B)  H)  H) ) ) ) .+case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_128 :  (eprop  ( (and  ( (dotpipp A)   (_125 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_126 :  (eprop False)  => A) ) ) )  ->  (_127 :  (eprop A)  ->  (eprop False) ) ) ) ) .+conj_case_9 :  (A : Uprop ->  (H :  (eprop  ( (iff A)  False) )  ->  (_136 :  (_131 :  (eprop A)  ->  (eprop False) )  ->  (_135 :  (_132 :  (eprop False)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_133 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_134 :  (eprop False)  => A) ) ) ) ) ) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) ]  ( (conj_case_9 A)  H)  -->  ( (conj  ( (dotpipp A)   (_129 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_130 :  (eprop False)  => A) ) ) .+[A : Uprop, H :  (eprop  ( (iff A)  False) ) , var_14 :  (_137 :  (eprop A)  ->  (eprop False) ) , var_15 :  (_138 :  (eprop False)  ->  (eprop A) ) ]  ( ( (case_9 A)  H)   ( ( ( (conj_case_9 A)  H)  var_14)  var_15) )  -->  ( ( (H欧0 :  (eprop  ( (dotpipp A)   (_140 :  (eprop A)  => False) ) )  =>  (H0 :  (eprop  ( (dotpipp False)   (_139 :  (eprop False)  => A) ) )  => H欧0) )  var_14)  var_15) .+neg_false :  (A : Uprop ->  (eprop  ( (iff  (not A) )   ( (iff A)  False) ) ) ) .+[] neg_false -->  (A :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (dotpipp A)   (_118 :  (eprop A)  => False) ) )   (_119 :  (eprop  ( (dotpipp A)   (_118 :  (eprop A)  => False) ) )  =>  ( (iff A)  False) ) ) )   ( (dotpipp  ( (iff A)  False) )   (_121 :  (eprop  ( (iff A)  False) )  =>  ( (dotpipp A)   (_120 :  (eprop A)  => False) ) ) ) )   (H :  (eprop  ( (dotpipp A)   (_124 :  (eprop A)  => False) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_122 :  (eprop A)  => False) ) )   ( (dotpipp False)   (_123 :  (eprop False)  => A) ) )  H)   (H1 :  (eprop False)  =>  ( (False_ind A)  H1) ) ) ) )   (H :  (eprop  ( (iff A)  False) )  =>  ( ( (case_9 A)  H)  H) ) ) ) .+and_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_168 :  (_165 :  (eprop B)  ->  (eprop A) )  ->  (_167 :  (_166 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_164 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_163 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (_141 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_142 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and A)  B) )   (_143 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_144 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and A)  B) )   (_156 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and A)  C) )   (_155 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp A)   (_154 :  (eprop A)  =>  ( (dotpipp B)   (_153 :  (eprop B)  =>  ( (and A)  C) ) ) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp A)   (_152 :  (eprop A)  =>  ( (dotpipp C)   (_151 :  (eprop C)  =>  ( (and A)  B) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_145 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_146 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp B)   (_148 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  C)   (H欧1 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H1欧2 :  (eprop  ( (dotpipp C)   (_147 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H2欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  C)   (H1欧3 :  (eprop A)  =>  (H6 :  (eprop B)  => H5) ) )  H0欧0) )   (H1欧2 H5) ) )   (H0 H5) ) )   (H2欧0 H4) ) ) ) )  H1欧1) )   (H欧0 H3欧0) ) )   (H1欧0 H4) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp B)   (_150 :  (eprop B)  =>  ( (and A)  C) ) ) )  =>  ( (H1欧1 :  (eprop  ( (dotpipp C)   (_149 :  (eprop C)  =>  ( (and A)  B) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)  B)   (H1欧2 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H2欧2 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)  B)   (H0欧1 :  (eprop A)  =>  (H6 :  (eprop C)  => H5) ) )  H欧0) )   (H0欧0 H5) ) )   (H H5) ) ) ) )  H2欧1) )   (H1欧1 H3欧0) ) )   (H2欧0 H4) ) )   (H1欧0 H4) ) )   (H0 H3欧0) ) ) ) )   (H2欧0 :  (eprop A)  =>  (H4 :  (eprop C)  =>  (H3  ( ( ( (conj A)  C)  H2欧0)  H4) ) ) ) ) )   (H1欧0 :  (eprop A)  =>  (H4 :  (eprop B)  =>  (H2  ( ( ( (conj A)  B)  H1欧0)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_157 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_158 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_162 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_161 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_159 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_160 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H1欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H4 :  (eprop A)  =>  (H5 :  (eprop B)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2欧0)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H5) ) )   (H H5) ) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H4 :  (eprop A)  =>  (H5 :  (eprop C)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H3欧0)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H5) ) )   (H0 H5) ) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_196 :  (_193 :  (eprop B)  ->  (eprop A) )  ->  (_195 :  (_194 :  (eprop C)  ->  (eprop A) )  ->  (eprop  ( (iff  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] and_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_192 :  (eprop B)  => A) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_191 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (_169 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_170 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (and B)  A) )   (_171 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_172 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (and B)  A) )   (_184 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (and C)  A) )   (_183 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp B)   (_182 :  (eprop B)  =>  ( (dotpipp A)   (_181 :  (eprop A)  =>  ( (and C)  A) ) ) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp C)   (_180 :  (eprop C)  =>  ( (dotpipp A)   (_179 :  (eprop A)  =>  ( (and B)  A) ) ) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_173 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_174 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp A)   (_176 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  C)   (H欧1 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H1欧2 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp A)   (_175 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  C)   (H0欧1 :  (eprop B)  =>  (H6 :  (eprop A)  => H欧1) ) )  H2欧1) )   (H0欧0 H4) ) )   (H2欧0 H欧1) ) )   (H0 H欧1) ) ) ) )  H1欧1) )   (H欧0 H4) ) )   (H1欧0 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H0欧0 :  (eprop  ( (dotpipp A)   (_178 :  (eprop A)  =>  ( (and B)  A) ) ) )  =>  ( (H2欧1 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)  B)   (H0欧1 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H2欧2 :  (eprop A)  =>  ( (H欧0 :  (eprop  ( (dotpipp A)   (_177 :  (eprop A)  =>  ( (and C)  A) ) ) )  =>  ( (H1欧1 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)  B)   (H欧1 :  (eprop C)  =>  (H6 :  (eprop A)  => H0欧1) ) )  H1欧1) )   (H欧0 H4) ) )   (H1欧0 H0欧1) ) )   (H H0欧1) ) ) ) )  H2欧1) )   (H0欧0 H4) ) )   (H2欧0 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H2欧0 :  (eprop C)  =>  (H4 :  (eprop A)  =>  (H3  ( ( ( (conj C)  A)  H2欧0)  H4) ) ) ) ) )   (H1欧0 :  (eprop B)  =>  (H4 :  (eprop A)  =>  (H2  ( ( ( (conj B)  A)  H1欧0)  H4) ) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_185 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_186 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_190 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_189 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_187 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_188 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H1欧0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H4 :  (eprop B)  =>  (H5 :  (eprop A)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj C)  A)  H欧0)  H2欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H4 :  (eprop C)  =>  (H5 :  (eprop A)  =>  ( (H1欧1 :  (eprop A)  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop A)  =>  ( (H欧0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H0欧0)  H3欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_220 :  (_217 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_219 :  (_218 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_216 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_215 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (_197 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_198 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or A)  B) )   (_199 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_200 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or A)  B) )   (_208 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or A)  C) )   (_207 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp A)   (_206 :  (eprop A)  =>  ( (or A)  C) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp B)   (_205 :  (eprop B)  =>  ( (or A)  C) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp A)   (_204 :  (eprop A)  =>  ( (or A)  B) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp C)   (_203 :  (eprop C)  =>  ( (or A)  B) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_201 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_202 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H4欧0 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H1欧1 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )   (H5欧0 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H5 H1欧1) ) )   (H6欧0 H4欧0) ) )   (H0 H1欧1) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )   (H5欧0 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H5 H1欧1) ) )   (H6欧0 H4欧0) ) )   (H0 H1欧1) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )  H欧1) )   (H1欧0 H4欧0) ) ) )   (H4欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H5欧0 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  C)   (H1欧1 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  C)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H5欧0) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )  H0欧1) )   (H1欧0 H5欧0) ) ) )   (H5欧0 :  (eprop B)  => H4欧0) )  H0欧0) )   (H5 H4欧0) ) )   (H0 H4欧0) ) ) )  H欧0) )   (H4 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H5欧0 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H1欧1 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )   (H4欧0 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H4 H2欧1) ) )   (H6欧0 H5欧0) ) )   (H H2欧1) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H5欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )   (H4欧0 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H4 H2欧1) ) )   (H6欧0 H5欧0) ) )   (H H2欧1) ) )   (H6 H5欧0) ) ) )  H0欧2) )   (H2欧0 H5欧0) ) ) )  H0欧1) )   (H1欧0 H5欧0) ) ) )   (H5欧0 :  (eprop B)  =>  ( (H0欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H4欧0 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)  B)   (H1欧1 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )   (H1欧1 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)  B)   (H2欧1 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )   (H2欧1 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H4欧0) ) )   (H6 H4欧0) ) ) )  H欧2) )   (H2欧0 H4欧0) ) ) )  H欧1) )   (H1欧0 H4欧0) ) ) )   (H4欧0 :  (eprop C)  => H5欧0) )  H欧0) )   (H4 H5欧0) ) )   (H H5欧0) ) ) )  H0欧0) )   (H5 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H5 :  (eprop C)  =>  (H3  ( ( (or_intror A)  C)  H5) ) ) ) )   (H2欧0 :  (eprop A)  =>  (H3  ( ( (or_introl A)  C)  H2欧0) ) ) ) )   (H4 :  (eprop B)  =>  (H2  ( ( (or_intror A)  B)  H4) ) ) ) )   (H1欧0 :  (eprop A)  =>  (H2  ( ( (or_introl A)  B)  H1欧0) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_209 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_210 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H2 :  (eprop  ( (dotpipp B)   (_214 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_213 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_211 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_212 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H1欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  C)  H4) ) )   (H4 :  (eprop B)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_intror A)  C)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H4 :  (eprop A)  =>  ( ( (or_introl A)  B)  H4) ) )   (H4 :  (eprop C)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+or_cancel_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_244 :  (_241 :  (eprop B)  ->  (eprop  (not A) ) )  ->  (_243 :  (_242 :  (eprop C)  ->  (eprop  (not A) ) )  ->  (eprop  ( (iff  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   ( (iff B)  C) ) ) ) ) ) ) ) .+[] or_cancel_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp B)   (_240 :  (eprop B)  =>  (not A) ) ) )  =>  (H0 :  (eprop  ( (dotpipp C)   (_239 :  (eprop C)  =>  (not A) ) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (_221 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( (iff B)  C) ) ) )   ( (dotpipp  ( (iff B)  C) )   (_222 :  (eprop  ( (iff B)  C) )  =>  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) )   (H1 :  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp  ( (or B)  A) )   (_223 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_224 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   ( (iff B)  C) )   (H2 :  (eprop  ( (dotpipp  ( (or B)  A) )   (_232 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )  =>  (H3 :  (eprop  ( (dotpipp  ( (or C)  A) )   (_231 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )  =>  ( (H1欧0 :  (eprop  ( (dotpipp B)   (_230 :  (eprop B)  =>  ( (or C)  A) ) ) )  =>  ( (H4 :  (eprop  ( (dotpipp A)   (_229 :  (eprop A)  =>  ( (or C)  A) ) ) )  =>  ( (H2欧0 :  (eprop  ( (dotpipp C)   (_228 :  (eprop C)  =>  ( (or B)  A) ) ) )  =>  ( (H5 :  (eprop  ( (dotpipp A)   (_227 :  (eprop A)  =>  ( (or B)  A) ) ) )  =>  ( ( ( (conj  ( (dotpipp B)   (_225 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_226 :  (eprop C)  => B) ) )   (H3欧0 :  (eprop B)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H1欧1 :  (eprop C)  =>  ( (H欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  => H1欧1) )   (H2欧1 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H4欧0 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind C)  H6欧0) )   (H欧1 H2欧1) ) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )  H0欧1) )   (H4 H2欧1) ) ) )  H0欧0) )   (H2欧0 H1欧1) ) )   (H0 H1欧1) ) ) )   (H1欧1 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  C)   (H4欧0 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )   (H2欧1 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H2欧0 H4欧0) ) )   (H6欧0 H1欧1) ) )   (H0 H4欧0) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H2欧1 :  (eprop B)  =>  ( (False_ind C)  H0欧0) ) )   (H2欧1 :  (eprop A)  =>  ( (False_ind C)  H0欧0) ) )  H6欧1) )   (H2欧0 H4欧0) ) )   (H6欧0 H1欧1) ) )   (H0 H4欧0) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  C)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (False_ind C)  H欧3) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )  H欧1) )   (H4 H1欧1) ) ) )  H欧0) )   (H1欧0 H3欧0) ) )   (H H3欧0) ) ) )   (H3欧0 :  (eprop C)  =>  ( (H6 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H2欧1 :  (eprop B)  =>  ( (H0欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  => H2欧1) )   (H1欧1 :  (eprop A)  =>  ( (H欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H4欧0 :  (eprop C)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop False)  =>  ( (False_ind B)  H6欧0) )   (H0欧1 H1欧1) ) )   (H6 H1欧1) ) ) )  H欧2) )   (H5 H1欧1) ) ) )  H欧1) )   (H4 H1欧1) ) ) )  H欧0) )   (H1欧0 H2欧1) ) )   (H H2欧1) ) ) )   (H2欧1 :  (eprop A)  =>  ( (H0欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H4欧0 :  (eprop C)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )   (H1欧1 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H1欧0 H5欧0) ) )   (H6欧0 H2欧1) ) )   (H H5欧0) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )   (H4欧0 :  (eprop A)  =>  ( (H0欧2 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)  B)   (H5欧0 :  (eprop B)  =>  ( (H0欧3 :  (eprop False)  =>  ( (H6欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop False)  =>  ( (H6欧1 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)  B)   (H1欧1 :  (eprop C)  =>  ( (False_ind B)  H欧0) ) )   (H1欧1 :  (eprop A)  =>  ( (False_ind B)  H欧0) ) )  H6欧1) )   (H1欧0 H5欧0) ) )   (H6欧0 H2欧1) ) )   (H H5欧0) ) )   (H6 H2欧1) ) ) )   (H5欧0 :  (eprop A)  =>  ( (H0欧3 :  (eprop False)  =>  ( (False_ind B)  H0欧3) )   (H6 H2欧1) ) ) )  H0欧2) )   (H5 H2欧1) ) ) )  H0欧1) )   (H4 H2欧1) ) ) )  H0欧0) )   (H2欧0 H3欧0) ) )   (H0 H3欧0) ) ) ) )   (H5 :  (eprop A)  =>  (H3  ( ( (or_intror C)  A)  H5) ) ) ) )   (H2欧0 :  (eprop C)  =>  (H3  ( ( (or_introl C)  A)  H2欧0) ) ) ) )   (H4 :  (eprop A)  =>  (H2  ( ( (or_intror B)  A)  H4) ) ) ) )   (H1欧0 :  (eprop B)  =>  (H2  ( ( (or_introl B)  A)  H1欧0) ) ) ) ) ) )  H1) ) )   (H1 :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_233 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_234 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H2 :  (eprop  ( (dotpipp B)   (_238 :  (eprop B)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_237 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_235 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_236 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H1欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H4 :  (eprop B)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( (H2欧0 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_introl C)  A)  H欧0) )   (H3 H欧0) ) )   (H0 H欧0) ) )   (H2 H4) ) )   (H H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror C)  A)  H4) ) )  H1欧0) ) )   (H1欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H4 :  (eprop C)  =>  ( (H1欧1 :  (eprop  (not A) )  =>  ( (H0欧0 :  (eprop B)  =>  ( (H3欧0 :  (eprop  (not A) )  =>  ( (H欧0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H0欧0) )   (H2 H0欧0) ) )   (H H0欧0) ) )   (H3 H4) ) )   (H0 H4) ) ) )   (H4 :  (eprop A)  =>  ( ( (or_intror B)  A)  H4) ) )  H1欧0) ) ) ) ) )  H1) ) ) ) ) ) ) ) .+and_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_251 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and A)  B) )   ( (and A)  C) ) ) ) ) ) ) .+[] and_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_245 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_246 :  (eprop C)  => B) ) )   ( (iff  ( (and A)  B) )   ( (and A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_250 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_249 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and A)  B) )   (_247 :  (eprop  ( (and A)  B) )  =>  ( (and A)  C) ) ) )   ( (dotpipp  ( (and A)  C) )   (_248 :  (eprop  ( (and A)  C) )  =>  ( (and A)  B) ) ) )   (H欧0 :  (eprop  ( (and A)  B) )  =>  ( ( ( ( (and_ind A)  B)   ( (and A)  C) )   (H2 :  (eprop A)  =>  (H3 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj A)  C)  H2)  H欧1) )   (H1 H欧1) ) )   (H0 H3) ) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (and A)  C) )  =>  ( ( ( ( (and_ind A)  C)   ( (and A)  B) )   (H2 :  (eprop A)  =>  (H3 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( ( (conj A)  B)  H2)  H欧1) )   (H0 H欧1) ) )   (H1 H3) ) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+and_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_258 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (and B)  A) )   ( (and C)  A) ) ) ) ) ) ) .+[] and_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_252 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_253 :  (eprop C)  => B) ) )   ( (iff  ( (and B)  A) )   ( (and C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_257 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_256 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and B)  A) )   (_254 :  (eprop  ( (and B)  A) )  =>  ( (and C)  A) ) ) )   ( (dotpipp  ( (and C)  A) )   (_255 :  (eprop  ( (and C)  A) )  =>  ( (and B)  A) ) ) )   (H欧0 :  (eprop  ( (and B)  A) )  =>  ( ( ( ( (and_ind B)  A)   ( (and C)  A) )   (H2 :  (eprop B)  =>  (H3 :  (eprop A)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( ( (conj C)  A)  H欧1)  H3) )   (H1 H欧1) ) )   (H0 H2) ) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (and C)  A) )  =>  ( ( ( ( (and_ind C)  A)   ( (and B)  A) )   (H2 :  (eprop C)  =>  (H3 :  (eprop A)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( ( (conj B)  A)  H欧1)  H3) )   (H0 H欧1) ) )   (H1 H2) ) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_l :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_265 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or A)  B) )   ( (or A)  C) ) ) ) ) ) ) .+[] or_iff_compat_l -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_259 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_260 :  (eprop C)  => B) ) )   ( (iff  ( (or A)  B) )   ( (or A)  C) ) )   (H0 :  (eprop  ( (dotpipp B)   (_264 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_263 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or A)  B) )   (_261 :  (eprop  ( (or A)  B) )  =>  ( (or A)  C) ) ) )   ( (dotpipp  ( (or A)  C) )   (_262 :  (eprop  ( (or A)  C) )  =>  ( (or A)  B) ) ) )   (H欧0 :  (eprop  ( (or A)  B) )  =>  ( ( ( ( ( (or_ind A)  B)   ( (or A)  C) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  C)  H2) ) )   (H2 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_intror A)  C)  H欧1) )   (H1 H欧1) ) )   (H0 H2) ) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (or A)  C) )  =>  ( ( ( ( ( (or_ind A)  C)   ( (or A)  B) )   (H2 :  (eprop A)  =>  ( ( (or_introl A)  B)  H2) ) )   (H2 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( (or_intror A)  B)  H欧1) )   (H0 H欧1) ) )   (H1 H2) ) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+or_iff_compat_r :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_272 :  (eprop  ( (iff B)  C) )  ->  (eprop  ( (iff  ( (or B)  A) )   ( (or C)  A) ) ) ) ) ) ) .+[] or_iff_compat_r -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff B)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp B)   (_266 :  (eprop B)  => C) ) )   ( (dotpipp C)   (_267 :  (eprop C)  => B) ) )   ( (iff  ( (or B)  A) )   ( (or C)  A) ) )   (H0 :  (eprop  ( (dotpipp B)   (_271 :  (eprop B)  => C) ) )  =>  (H1 :  (eprop  ( (dotpipp C)   (_270 :  (eprop C)  => B) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (or B)  A) )   (_268 :  (eprop  ( (or B)  A) )  =>  ( (or C)  A) ) ) )   ( (dotpipp  ( (or C)  A) )   (_269 :  (eprop  ( (or C)  A) )  =>  ( (or B)  A) ) ) )   (H欧0 :  (eprop  ( (or B)  A) )  =>  ( ( ( ( ( (or_ind B)  A)   ( (or C)  A) )   (H2 :  (eprop B)  =>  ( (H欧1 :  (eprop C)  =>  ( (H0欧0 :  (eprop B)  =>  ( ( (or_introl C)  A)  H欧1) )   (H1 H欧1) ) )   (H0 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror C)  A)  H2) ) )  H欧0) ) )   (H欧0 :  (eprop  ( (or C)  A) )  =>  ( ( ( ( ( (or_ind C)  A)   ( (or B)  A) )   (H2 :  (eprop C)  =>  ( (H欧1 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( ( (or_introl B)  A)  H欧1) )   (H0 H欧1) ) )   (H1 H2) ) ) )   (H2 :  (eprop A)  =>  ( ( (or_intror B)  A)  H2) ) )  H欧0) ) ) ) ) )  H) ) ) ) ) .+case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_277 :  (eprop  ( (and  ( (dotpipp A)   (_273 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_274 :  (eprop B)  => A) ) ) )  ->  (eprop  ( (and  ( (dotpipp A)   (_275 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_276 :  (eprop B)  => A) ) ) ) ) ) ) ) .+conj_case_10 :  (A : Uprop ->  (B : Uprop ->  (H :  (eprop  ( (iff A)  B) )  ->  (_285 :  (_280 :  (eprop A)  ->  (eprop B) )  ->  (_284 :  (_281 :  (eprop B)  ->  (eprop A) )  ->  (eprop  ( (and  ( (dotpipp A)   (_282 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_283 :  (eprop B)  => A) ) ) ) ) ) ) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) ]  ( ( (conj_case_10 A)  B)  H)  -->  ( (conj  ( (dotpipp A)   (_278 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_279 :  (eprop B)  => A) ) ) .+[A : Uprop, B : Uprop, H :  (eprop  ( (iff A)  B) ) , var_16 :  (_286 :  (eprop A)  ->  (eprop B) ) , var_17 :  (_287 :  (eprop B)  ->  (eprop A) ) ]  ( ( ( (case_10 A)  B)  H)   ( ( ( ( (conj_case_10 A)  B)  H)  var_16)  var_17) )  -->  ( ( (H欧0 :  (eprop  ( (dotpipp A)   (_291 :  (eprop A)  => B) ) )  =>  (H0 :  (eprop  ( (dotpipp B)   (_290 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_288 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_289 :  (eprop B)  => A) ) )  H欧0)  H0) ) )  var_16)  var_17) .+iff_and :  (A : Uprop ->  (B : Uprop ->  (_294 :  (eprop  ( (iff A)  B) )  ->  (eprop  ( (and  ( (dotpipp A)   (_292 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_293 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( (case_10 A)  B)  H)  H) ) ) ) .+iff_to_and :  (A : Uprop ->  (B : Uprop ->  (eprop  ( (iff  ( (iff A)  B) )   ( (and  ( (dotpipp A)   (_317 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_318 :  (eprop B)  => A) ) ) ) ) ) ) .+[] iff_to_and -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  ( ( ( (conj  ( (dotpipp  ( (iff A)  B) )   (_297 :  (eprop  ( (iff A)  B) )  =>  ( (and  ( (dotpipp A)   (_295 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_296 :  (eprop B)  => A) ) ) ) ) )   ( (dotpipp  ( (and  ( (dotpipp A)   (_298 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_299 :  (eprop B)  => A) ) ) )   (_300 :  (eprop  ( (and  ( (dotpipp A)   (_298 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_299 :  (eprop B)  => A) ) ) )  =>  ( (iff A)  B) ) ) )   (H :  (eprop  ( (iff A)  B) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_301 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_302 :  (eprop B)  => A) ) )   ( (and  ( (dotpipp A)   (_303 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_304 :  (eprop B)  => A) ) ) )   (H0 :  (eprop  ( (dotpipp A)   (_308 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_307 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_305 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_306 :  (eprop B)  => A) ) )   (H欧0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H0欧0 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H欧0) ) ) )   (H欧0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H1欧0 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H欧0) ) ) ) ) ) )  H) ) )   (H :  (eprop  ( (and  ( (dotpipp A)   (_315 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_316 :  (eprop B)  => A) ) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_309 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_310 :  (eprop B)  => A) ) )   ( (iff A)  B) )   (H0 :  (eprop  ( (dotpipp A)   (_314 :  (eprop A)  => B) ) )  =>  (H1 :  (eprop  ( (dotpipp B)   (_313 :  (eprop B)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp A)   (_311 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_312 :  (eprop B)  => A) ) )   (H欧0 :  (eprop A)  =>  ( (H2 :  (eprop B)  =>  ( (H0欧0 :  (eprop A)  => H2)   (H1 H2) ) )   (H0 H欧0) ) ) )   (H欧0 :  (eprop B)  =>  ( (H2 :  (eprop A)  =>  ( (H1欧0 :  (eprop B)  => H2)   (H0 H2) ) )   (H1 H欧0) ) ) ) ) ) )  H) ) ) ) ) .+IF_then_else :  (P : Uprop ->  (Q : Uprop ->  (R : Uprop -> Uprop) ) ) .+[] IF_then_else -->  (P :  (etype dotprop)  =>  (Q :  (etype dotprop)  =>  (R :  (etype dotprop)  =>  ( (or  ( (and P)  Q) )   ( (and  (not P) )  R) ) ) ) ) .+ex :  (A : Utype ->  (P :  (_319 :  (etype A)  -> Uprop)  -> Uprop) ) .+ex_intro :  (A : Utype ->  (P :  (_320 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_321 :  (eprop  (P x) )  ->  (eprop  ( (ex A)  P) ) ) ) ) ) .+case_11 :  (A : Utype ->  (P :  (_322 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_323 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (_324 :  (eprop  ( (ex A)  P) )  ->  (eprop P欧0) ) ) ) ) ) ) .+ex_intro_case_11 :  (A : Utype ->  (P :  (_327 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_328 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (x :  (etype A)  ->  (_329 :  (eprop  (P x) )  ->  (eprop  ( (ex A)  P) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_330 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_331 :  (eprop  (P x) )  ->  (eprop P欧0) ) ) , e :  (eprop  ( (ex A)  P) ) ]  ( ( ( ( (ex_intro_case_11 A)  P)  P欧0)  f)  e)  -->  ( (ex_intro A)  P) .+[A : Utype, P :  (_325 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_326 :  (eprop  (P x) )  ->  (eprop P欧0) ) ) , e :  (eprop  ( (ex A)  P) ) , var_18 :  (etype A) , var_19 :  (eprop  (P var_18) ) ]  ( ( ( ( ( (case_11 A)  P)  P欧0)  f)  e)   ( ( ( ( ( ( (ex_intro_case_11 A)  P)  P欧0)  f)  e)  var_18)  var_19) )  -->  ( (f var_18)  var_19) .+ex_ind :  (A : Utype ->  (P :  (_334 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_335 :  (eprop  (P x) )  ->  (eprop P欧0) ) )  ->  (e :  (eprop  ( (ex A)  P) )  ->  (eprop P欧0) ) ) ) ) ) .+[] ex_ind -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_333 :  (etype A)  => dotprop) ) )  =>  (P欧0 :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpipp  (P x) )   (_332 :  (eprop  (P x) )  => P欧0) ) ) ) )  =>  (e :  (eprop  ( (ex A)  P) )  =>  ( ( ( ( ( (case_11 A)  P)  P欧0)  f)  e)  e) ) ) ) ) ) .+ex2 :  (A : Utype ->  (P :  (_336 :  (etype A)  -> Uprop)  ->  (Q :  (_337 :  (etype A)  -> Uprop)  -> Uprop) ) ) .+ex_intro2 :  (A : Utype ->  (P :  (_338 :  (etype A)  -> Uprop)  ->  (Q :  (_339 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_341 :  (eprop  (P x) )  ->  (_340 :  (eprop  (Q x) )  ->  (eprop  ( ( (ex2 A)  P)  Q) ) ) ) ) ) ) ) .+case_12 :  (A : Utype ->  (P :  (_342 :  (etype A)  -> Uprop)  ->  (Q :  (_343 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_345 :  (eprop  (P x) )  ->  (_344 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (_346 :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (eprop P欧0) ) ) ) ) ) ) ) .+ex_intro2_case_12 :  (A : Utype ->  (P :  (_351 :  (etype A)  -> Uprop)  ->  (Q :  (_352 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_354 :  (eprop  (P x) )  ->  (_353 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (x :  (etype A)  ->  (_356 :  (eprop  (P x) )  ->  (_355 :  (eprop  (Q x) )  ->  (eprop  ( ( (ex2 A)  P)  Q) ) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_357 :  (etype A)  -> Uprop) , Q :  (_358 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_360 :  (eprop  (P x) )  ->  (_359 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) ) , e :  (eprop  ( ( (ex2 A)  P)  Q) ) ]  ( ( ( ( ( (ex_intro2_case_12 A)  P)  Q)  P欧0)  f)  e)  -->  ( ( (ex_intro2 A)  P)  Q) .+[A : Utype, P :  (_347 :  (etype A)  -> Uprop) , Q :  (_348 :  (etype A)  -> Uprop) , P欧0 : Uprop, f :  (x :  (etype A)  ->  (_350 :  (eprop  (P x) )  ->  (_349 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) ) , e :  (eprop  ( ( (ex2 A)  P)  Q) ) , var_20 :  (etype A) , var_21 :  (eprop  (P var_20) ) , var_22 :  (eprop  (Q var_20) ) ]  ( ( ( ( ( ( (case_12 A)  P)  Q)  P欧0)  f)  e)   ( ( ( ( ( ( ( ( (ex_intro2_case_12 A)  P)  Q)  P欧0)  f)  e)  var_20)  var_21)  var_22) )  -->  ( ( (f var_20)  var_21)  var_22) .+ex2_ind :  (A : Utype ->  (P :  (_365 :  (etype A)  -> Uprop)  ->  (Q :  (_366 :  (etype A)  -> Uprop)  ->  (P欧0 : Uprop ->  (f :  (x :  (etype A)  ->  (_368 :  (eprop  (P x) )  ->  (_367 :  (eprop  (Q x) )  ->  (eprop P欧0) ) ) )  ->  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  ->  (eprop P欧0) ) ) ) ) ) ) .+[] ex2_ind -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_364 :  (etype A)  => dotprop) ) )  =>  (Q :  (etype  ( (dotpitt A)   (_363 :  (etype A)  => dotprop) ) )  =>  (P欧0 :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpipp  (P x) )   (_362 :  (eprop  (P x) )  =>  ( (dotpipp  (Q x) )   (_361 :  (eprop  (Q x) )  => P欧0) ) ) ) ) ) )  =>  (e :  (eprop  ( ( (ex2 A)  P)  Q) )  =>  ( ( ( ( ( ( (case_12 A)  P)  Q)  P欧0)  f)  e)  e) ) ) ) ) ) ) .+all :  (A : Utype ->  (P :  (_370 :  (etype A)  -> Uprop)  -> Uprop) ) .+[] all -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_369 :  (etype A)  => dotprop) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  (P x) ) ) ) ) .+inst :  (A : Utype ->  (P :  (_372 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  ->  (_373 :  (eprop  ( (all A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  ->  (eprop  (P x) ) ) ) ) ) .+[] inst -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_371 :  (etype A)  => dotprop) ) )  =>  (x :  (etype A)  =>  (H :  (eprop  ( (dotpitp A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  =>  (H x) ) ) ) ) .+gen :  (A : Utype ->  (P :  (_376 :  (etype A)  -> Uprop)  ->  (B : Uprop ->  (f :  (y :  (etype A)  ->  (_377 :  (eprop B)  ->  (eprop  (P y) ) ) )  ->  (_378 :  (eprop B)  ->  (eprop  ( (all A)  P) ) ) ) ) ) ) .+[] gen -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_375 :  (etype A)  => dotprop) ) )  =>  (B :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (y :  (etype A)  =>  ( (dotpipp B)   (_374 :  (eprop B)  =>  (P y) ) ) ) ) )  =>  (H :  (eprop B)  =>  (x :  (etype A)  =>  ( (f x)  H) ) ) ) ) ) ) .+eq :  (A : Utype ->  (x :  (etype A)  ->  (_379 :  (etype A)  -> Uprop) ) ) .+refl_equal :  (A : Utype ->  (x :  (etype A)  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) .+case_13 :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_380 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_381 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (etype  (P y欧0) ) ) ) ) ) ) ) ) ) .+refl_equal_case_13 :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_383 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , P :  (_384 :  (etype A)  -> Utype) , f :  (etype  (P x) ) , y :  (etype A) , e :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (refl_equal_case_13 A)  x)  P)  f)  y)  e)  -->  ( (refl_equal A)  x) .+[A : Utype, x :  (etype A) , P :  (_382 :  (etype A)  -> Utype) , f :  (etype  (P x) ) , y :  (etype A) , e :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( ( ( (case_13 A)  x)  P)  f)  y)  e)  x)   ( ( ( ( ( (refl_equal_case_13 A)  x)  P)  f)  y)  e) )  --> f.+eq_rect :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_386 :  (etype A)  -> Utype)  ->  (f :  (etype  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (etype  (P y) ) ) ) ) ) ) ) .+[] eq_rect -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_385 :  (etype A)  => dottype) ) )  =>  (f :  (etype  (P x) )  =>  (y :  (etype A)  =>  (e :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( ( ( (case_13 A)  x)  P)  f)  y)  e)  y)  e) ) ) ) ) ) ) .+eq_ind :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_388 :  (etype A)  -> Uprop)  ->  (f :  (eprop  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  (P y) ) ) ) ) ) ) ) .+[] eq_ind -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_387 :  (etype A)  => dotprop) ) )  =>  ( ( (eq_rect A)  x)  P) ) ) ) .+eq_rec :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_390 :  (etype A)  -> Uset)  ->  (f :  (eset  (P x) )  ->  (y :  (etype A)  ->  (e :  (eprop  ( ( (eq A)  x)  y) )  ->  (eset  (P y) ) ) ) ) ) ) ) .+[] eq_rec -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_389 :  (etype A)  => dotset) ) )  =>  ( ( (eq_rect A)  x)  P) ) ) ) .+case_14 :  (A : Uprop ->  (C : Uprop ->  (h1 :  (eprop A)  ->  (h2 :  (_391 :  (eprop A)  ->  (eprop False) )  ->  (f :  (eprop False)  ->  (_392 :  (eprop False)  ->  (eprop C) ) ) ) ) ) ) .+absurd :  (A : Uprop ->  (C : Uprop ->  (_396 :  (eprop A)  ->  (_395 :  (eprop  (not A) )  ->  (eprop C) ) ) ) ) .+[] absurd -->  (A :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (h1 :  (eprop A)  =>  (h2 :  (eprop  ( (dotpipp A)   (_394 :  (eprop A)  => False) ) )  =>  ( (f :  (eprop False)  =>  ( ( ( ( ( (case_14 A)  C)  h1)  h2)  f)  f) )   (h2 h1) ) ) ) ) ) .+case_15 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_397 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (eprop  ( ( (eq A)  y欧0)  x) ) ) ) ) ) ) ) .+refl_equal_case_15 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( (refl_equal_case_15 A)  x)  y)  H)  -->  ( (refl_equal A)  x) .+[A : Utype, x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (case_15 A)  x)  y)  H)  x)   ( ( ( (refl_equal_case_15 A)  x)  y)  H) )  -->  ( (refl_equal A)  x) .+sym_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_398 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  y)  x) ) ) ) ) ) .+[] sym_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( (case_15 A)  x)  y)  H)  y)  H) ) ) ) ) .+case_16 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (H0 :  (eprop  ( ( (eq A)  y)  z) )  ->  (y欧0 :  (etype A)  ->  (_399 :  (eprop  ( ( (eq A)  y)  y欧0) )  ->  (eprop  ( ( (eq A)  x)  y欧0) ) ) ) ) ) ) ) ) ) .+refl_equal_case_16 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (H0 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  y)  y) ) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , z :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) , H0 :  (eprop  ( ( (eq A)  y)  z) ) ]  ( ( ( ( ( (refl_equal_case_16 A)  x)  y)  z)  H)  H0)  -->  ( (refl_equal A)  y) .+[A : Utype, x :  (etype A) , y :  (etype A) , z :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) , H0 :  (eprop  ( ( (eq A)  y)  z) ) ]  ( ( ( ( ( ( ( (case_16 A)  x)  y)  z)  H)  H0)  y)   ( ( ( ( ( (refl_equal_case_16 A)  x)  y)  z)  H)  H0) )  --> H.+trans_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_401 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_400 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  x)  z) ) ) ) ) ) ) ) .+[] trans_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  (H0 :  (eprop  ( ( (eq A)  y)  z) )  =>  ( ( ( ( ( ( ( (case_16 A)  x)  y)  z)  H)  H0)  z)  H0) ) ) ) ) ) ) .+case_17 :  (A : Utype ->  (B : Utype ->  (f :  (_402 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (y欧0 :  (etype A)  ->  (_403 :  (eprop  ( ( (eq A)  x)  y欧0) )  ->  (eprop  ( ( (eq B)   (f x) )   (f y欧0) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_17 :  (A : Utype ->  (B : Utype ->  (f :  (_405 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (H :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  x)  x) ) ) ) ) ) ) ) .+[A : Utype, B : Utype, f :  (_406 :  (etype A)  ->  (etype B) ) , x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( (refl_equal_case_17 A)  B)  f)  x)  y)  H)  -->  ( (refl_equal A)  x) .+[A : Utype, B : Utype, f :  (_404 :  (etype A)  ->  (etype B) ) , x :  (etype A) , y :  (etype A) , H :  (eprop  ( ( (eq A)  x)  y) ) ]  ( ( ( ( ( ( ( (case_17 A)  B)  f)  x)  y)  H)  x)   ( ( ( ( ( (refl_equal_case_17 A)  B)  f)  x)  y)  H) )  -->  ( (refl_equal B)   (f x) ) .+f_equal :  (A : Utype ->  (B : Utype ->  (f :  (_408 :  (etype A)  ->  (etype B) )  ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_409 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq B)   (f x) )   (f y) ) ) ) ) ) ) ) ) .+[] f_equal -->  (A :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A)   (_407 :  (etype A)  => B) ) )  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (H :  (eprop  ( ( (eq A)  x)  y) )  =>  ( ( ( ( ( ( ( (case_17 A)  B)  f)  x)  y)  H)  y)  H) ) ) ) ) ) ) .+case_18 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (h2 :  (eprop  ( ( (eq A)  y)  x) )  ->  (y欧0 :  (etype A)  ->  (_410 :  (eprop  ( ( (eq A)  y)  y欧0) )  ->  (h1欧0 :  (eprop  (not  ( ( (eq A)  y欧0)  y) ) )  ->  (eprop  ( ( (eq A)  y欧0)  y) ) ) ) ) ) ) ) ) ) .+refl_equal_case_18 :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (h2 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eprop  ( ( (eq A)  y)  y) ) ) ) ) ) ) .+[A : Utype, x :  (etype A) , y :  (etype A) , h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) ) , h2 :  (eprop  ( ( (eq A)  y)  x) ) ]  ( ( ( ( (refl_equal_case_18 A)  x)  y)  h1)  h2)  -->  ( (refl_equal A)  y) .+[A : Utype, x :  (etype A) , y :  (etype A) , h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) ) , h2 :  (eprop  ( ( (eq A)  y)  x) ) ]  ( ( ( ( ( ( (case_18 A)  x)  y)  h1)  h2)  y)   ( ( ( ( (refl_equal_case_18 A)  x)  y)  h1)  h2) )  -->  (h1欧0 :  (eprop  (not  ( ( (eq A)  y)  y) ) )  =>  ( (refl_equal A)  y) ) .+sym_not_eq :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_411 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (eprop  (not  ( ( (eq A)  y)  x) ) ) ) ) ) ) .+[] sym_not_eq -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (h1 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  =>  (h2 :  (eprop  ( ( (eq A)  y)  x) )  =>  (h1  ( ( ( ( ( ( ( (case_18 A)  x)  y)  h1)  h2)  x)  h2)  h1) ) ) ) ) ) ) .+sym_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_412 :  (eprop  ( ( (eq A)  x)  y) )  ->  (eprop  ( ( (eq A)  y)  x) ) ) ) ) ) .+[] sym_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  ( ( (sym_eq A)  x)  y) ) ) ) .+sym_not_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (_413 :  (eprop  (not  ( ( (eq A)  x)  y) ) )  ->  (eprop  (not  ( ( (eq A)  y)  x) ) ) ) ) ) ) .+[] sym_not_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  ( ( (sym_not_eq A)  x)  y) ) ) ) .+trans_equal :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_415 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_414 :  (eprop  ( ( (eq A)  y)  z) )  ->  (eprop  ( ( (eq A)  x)  z) ) ) ) ) ) ) ) .+[] trans_equal -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  ( ( ( (trans_eq A)  x)  y)  z) ) ) ) ) .+eq_ind_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_417 :  (etype A)  -> Uprop)  ->  (_419 :  (eprop  (P x) )  ->  (y :  (etype A)  ->  (_418 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eprop  (P y) ) ) ) ) ) ) ) .+[] eq_ind_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_416 :  (etype A)  => dotprop) ) )  =>  (H :  (eprop  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_ind A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+eq_rec_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_421 :  (etype A)  -> Uset)  ->  (_423 :  (eset  (P x) )  ->  (y :  (etype A)  ->  (_422 :  (eprop  ( ( (eq A)  y)  x) )  ->  (eset  (P y) ) ) ) ) ) ) ) .+[] eq_rec_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_420 :  (etype A)  => dotset) ) )  =>  (H :  (eset  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_rec A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+eq_rect_r :  (A : Utype ->  (x :  (etype A)  ->  (P :  (_425 :  (etype A)  -> Utype)  ->  (_427 :  (etype  (P x) )  ->  (y :  (etype A)  ->  (_426 :  (eprop  ( ( (eq A)  y)  x) )  ->  (etype  (P y) ) ) ) ) ) ) ) .+[] eq_rect_r -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (P :  (etype  ( (dotpitt A)   (_424 :  (etype A)  => dottype) ) )  =>  (H :  (etype  (P x) )  =>  (y :  (etype A)  =>  (H0 :  (eprop  ( ( (eq A)  y)  x) )  =>  ( ( ( ( ( (eq_rect A)  x)   (y欧0 :  (etype A)  =>  (P y欧0) ) )  H)  y)   ( ( ( (sym_eq A)  y)  x)  H0) ) ) ) ) ) ) ) .+case_19 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_429 :  (etype A1)  ->  (_428 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_431 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_430 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f y)  y2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_19 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_435 :  (etype A1)  ->  (_434 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_437 :  (etype A1)  ->  (_436 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( (refl_equal_case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  -->  ( (refl_equal A1)  x1) .+case_20 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_439 :  (etype A1)  ->  (_438 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_440 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f x1)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_20 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_444 :  (etype A1)  ->  (_443 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_446 :  (etype A1)  ->  (_445 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( (refl_equal_case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_442 :  (etype A1)  ->  (_441 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( (case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( (refl_equal_case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0) )  -->  ( (refl_equal B)   ( (f x1)  x2) ) .+[A1 : Utype, A2 : Utype, B : Utype, f :  (_433 :  (etype A1)  ->  (_432 :  (etype A2)  ->  (etype B) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( (case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  x1)   ( ( ( ( ( ( ( ( (refl_equal_case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( (case_20 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  H欧0)  y2)  H欧0) ) .+f_equal2 :  (A1 : Utype ->  (A2 : Utype ->  (B : Utype ->  (f :  (_450 :  (etype A1)  ->  (_449 :  (etype A2)  ->  (etype B) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (_452 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_451 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq B)   ( (f x1)  x2) )   ( (f y1)  y2) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal2 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_448 :  (etype A1)  =>  ( (dotpitt A2)   (_447 :  (etype A2)  => B) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( (case_19 A1)  A2)  B)  f)  x1)  y1)  x2)  y2)  H)  y1)  H) ) ) ) ) ) ) ) ) ) .+case_21 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_455 :  (etype A1)  ->  (_454 :  (etype A2)  ->  (_453 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_458 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_457 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_456 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f y)  y2)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_21 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_464 :  (etype A1)  ->  (_463 :  (etype A2)  ->  (_462 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_467 :  (etype A1)  ->  (_466 :  (etype A2)  ->  (_465 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  -->  ( (refl_equal A1)  x1) .+case_22 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_470 :  (etype A1)  ->  (_469 :  (etype A2)  ->  (_468 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_472 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_471 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f x1)  y)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_22 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_478 :  (etype A1)  ->  (_477 :  (etype A2)  ->  (_476 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_481 :  (etype A1)  ->  (_480 :  (etype A2)  ->  (_479 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_23 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_484 :  (etype A1)  ->  (_483 :  (etype A2)  ->  (_482 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_485 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f x1)  x2)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_23 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_491 :  (etype A1)  ->  (_490 :  (etype A2)  ->  (_489 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_494 :  (etype A1)  ->  (_493 :  (etype A2)  ->  (_492 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_488 :  (etype A1)  ->  (_487 :  (etype A2)  ->  (_486 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1) )  -->  ( (refl_equal B)   ( ( (f x1)  x2)  x3) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_475 :  (etype A1)  ->  (_474 :  (etype A2)  ->  (_473 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_23 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, B : Utype, f :  (_461 :  (etype A1)  ->  (_460 :  (etype A2)  ->  (_459 :  (etype A3)  ->  (etype B) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( (case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_22 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  H欧0)  y2)  H欧0) ) .+f_equal3 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (B : Utype ->  (f :  (_500 :  (etype A1)  ->  (_499 :  (etype A2)  ->  (_498 :  (etype A3)  ->  (etype B) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (_503 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_502 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_501 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq B)   ( ( (f x1)  x2)  x3) )   ( ( (f y1)  y2)  y3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal3 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_497 :  (etype A1)  =>  ( (dotpitt A2)   (_496 :  (etype A2)  =>  ( (dotpitt A3)   (_495 :  (etype A3)  => B) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( (case_21 A1)  A2)  A3)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) .+case_24 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_507 :  (etype A1)  ->  (_506 :  (etype A2)  ->  (_505 :  (etype A3)  ->  (_504 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_511 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_510 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_509 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_508 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f y)  y2)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_24 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_519 :  (etype A1)  ->  (_518 :  (etype A2)  ->  (_517 :  (etype A3)  ->  (_516 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_523 :  (etype A1)  ->  (_522 :  (etype A2)  ->  (_521 :  (etype A3)  ->  (_520 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  -->  ( (refl_equal A1)  x1) .+case_25 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_527 :  (etype A1)  ->  (_526 :  (etype A2)  ->  (_525 :  (etype A3)  ->  (_524 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_530 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_529 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_528 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  y)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_25 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_538 :  (etype A1)  ->  (_537 :  (etype A2)  ->  (_536 :  (etype A3)  ->  (_535 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_542 :  (etype A1)  ->  (_541 :  (etype A2)  ->  (_540 :  (etype A3)  ->  (_539 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_26 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_546 :  (etype A1)  ->  (_545 :  (etype A2)  ->  (_544 :  (etype A3)  ->  (_543 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_548 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (_547 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  x2)  y)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_26 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_556 :  (etype A1)  ->  (_555 :  (etype A2)  ->  (_554 :  (etype A3)  ->  (_553 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_560 :  (etype A1)  ->  (_559 :  (etype A2)  ->  (_558 :  (etype A3)  ->  (_557 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+case_27 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_564 :  (etype A1)  ->  (_563 :  (etype A2)  ->  (_562 :  (etype A3)  ->  (_561 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (y :  (etype A4)  ->  (_565 :  (eprop  ( ( (eq A4)  x4)  y) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f x1)  x2)  x3)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_27 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_573 :  (etype A1)  ->  (_572 :  (etype A2)  ->  (_571 :  (etype A3)  ->  (_570 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq A4)  x4)  x4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_577 :  (etype A1)  ->  (_576 :  (etype A2)  ->  (_575 :  (etype A3)  ->  (_574 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  -->  ( (refl_equal A4)  x4) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_569 :  (etype A1)  ->  (_568 :  (etype A2)  ->  (_567 :  (etype A3)  ->  (_566 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  x4)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2) )  -->  ( (refl_equal B)   ( ( ( (f x1)  x2)  x3)  x4) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_552 :  (etype A1)  ->  (_551 :  (etype A2)  ->  (_550 :  (etype A3)  ->  (_549 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1) )  -->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_27 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  H欧2)  y4)  H欧2) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_534 :  (etype A1)  ->  (_533 :  (etype A2)  ->  (_532 :  (etype A3)  ->  (_531 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_26 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, B : Utype, f :  (_515 :  (etype A1)  ->  (_514 :  (etype A2)  ->  (_513 :  (etype A3)  ->  (_512 :  (etype A4)  ->  (etype B) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_25 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  H欧0)  y2)  H欧0) ) .+f_equal4 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (B : Utype ->  (f :  (_585 :  (etype A1)  ->  (_584 :  (etype A2)  ->  (_583 :  (etype A3)  ->  (_582 :  (etype A4)  ->  (etype B) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (_589 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_588 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_587 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_586 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq B)   ( ( ( (f x1)  x2)  x3)  x4) )   ( ( ( (f y1)  y2)  y3)  y4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal4 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (A4 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_581 :  (etype A1)  =>  ( (dotpitt A2)   (_580 :  (etype A2)  =>  ( (dotpitt A3)   (_579 :  (etype A3)  =>  ( (dotpitt A4)   (_578 :  (etype A4)  => B) ) ) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (x4 :  (etype A4)  =>  (y4 :  (etype A4)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_24 A1)  A2)  A3)  A4)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+case_28 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_594 :  (etype A1)  ->  (_593 :  (etype A2)  ->  (_592 :  (etype A3)  ->  (_591 :  (etype A4)  ->  (_590 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (y :  (etype A1)  ->  (_599 :  (eprop  ( ( (eq A1)  x1)  y) )  ->  (_598 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_597 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_596 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_595 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f y)  y2)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_28 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_609 :  (etype A1)  ->  (_608 :  (etype A2)  ->  (_607 :  (etype A3)  ->  (_606 :  (etype A4)  ->  (_605 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (eprop  ( ( (eq A1)  x1)  x1) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_614 :  (etype A1)  ->  (_613 :  (etype A2)  ->  (_612 :  (etype A3)  ->  (_611 :  (etype A4)  ->  (_610 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  -->  ( (refl_equal A1)  x1) .+case_29 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_619 :  (etype A1)  ->  (_618 :  (etype A2)  ->  (_617 :  (etype A3)  ->  (_616 :  (etype A4)  ->  (_615 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (y :  (etype A2)  ->  (_623 :  (eprop  ( ( (eq A2)  x2)  y) )  ->  (_622 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_621 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_620 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  y)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_29 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_633 :  (etype A1)  ->  (_632 :  (etype A2)  ->  (_631 :  (etype A3)  ->  (_630 :  (etype A4)  ->  (_629 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (eprop  ( ( (eq A2)  x2)  x2) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_638 :  (etype A1)  ->  (_637 :  (etype A2)  ->  (_636 :  (etype A3)  ->  (_635 :  (etype A4)  ->  (_634 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  -->  ( (refl_equal A2)  x2) .+case_30 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_643 :  (etype A1)  ->  (_642 :  (etype A2)  ->  (_641 :  (etype A3)  ->  (_640 :  (etype A4)  ->  (_639 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (y :  (etype A3)  ->  (_646 :  (eprop  ( ( (eq A3)  x3)  y) )  ->  (_645 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_644 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  y)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_30 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_656 :  (etype A1)  ->  (_655 :  (etype A2)  ->  (_654 :  (etype A3)  ->  (_653 :  (etype A4)  ->  (_652 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (eprop  ( ( (eq A3)  x3)  x3) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_661 :  (etype A1)  ->  (_660 :  (etype A2)  ->  (_659 :  (etype A3)  ->  (_658 :  (etype A4)  ->  (_657 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  -->  ( (refl_equal A3)  x3) .+case_31 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_666 :  (etype A1)  ->  (_665 :  (etype A2)  ->  (_664 :  (etype A3)  ->  (_663 :  (etype A4)  ->  (_662 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (y :  (etype A4)  ->  (_668 :  (eprop  ( ( (eq A4)  x4)  y) )  ->  (_667 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  x3)  y)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_31 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_678 :  (etype A1)  ->  (_677 :  (etype A2)  ->  (_676 :  (etype A3)  ->  (_675 :  (etype A4)  ->  (_674 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (eprop  ( ( (eq A4)  x4)  x4) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_683 :  (etype A1)  ->  (_682 :  (etype A2)  ->  (_681 :  (etype A3)  ->  (_680 :  (etype A4)  ->  (_679 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  -->  ( (refl_equal A4)  x4) .+case_32 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_688 :  (etype A1)  ->  (_687 :  (etype A2)  ->  (_686 :  (etype A3)  ->  (_685 :  (etype A4)  ->  (_684 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (y :  (etype A5)  ->  (_689 :  (eprop  ( ( (eq A5)  x5)  y) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f x1)  x2)  x3)  x4)  y) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+refl_equal_case_32 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_699 :  (etype A1)  ->  (_698 :  (etype A2)  ->  (_697 :  (etype A3)  ->  (_696 :  (etype A4)  ->  (_695 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq A5)  x5)  x5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_704 :  (etype A1)  ->  (_703 :  (etype A2)  ->  (_702 :  (etype A3)  ->  (_701 :  (etype A4)  ->  (_700 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) , H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  -->  ( (refl_equal A5)  x5) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_694 :  (etype A1)  ->  (_693 :  (etype A2)  ->  (_692 :  (etype A3)  ->  (_691 :  (etype A4)  ->  (_690 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) , H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  x5)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3) )  -->  ( (refl_equal B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_673 :  (etype A1)  ->  (_672 :  (etype A2)  ->  (_671 :  (etype A3)  ->  (_670 :  (etype A4)  ->  (_669 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) , H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  x4)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2) )  -->  (H欧3 :  (eprop  ( ( (eq A5)  x5)  y5) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_32 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  H欧3)  y5)  H欧3) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_651 :  (etype A1)  ->  (_650 :  (etype A2)  ->  (_649 :  (etype A3)  ->  (_648 :  (etype A4)  ->  (_647 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) , H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  x3)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1) )  -->  (H欧2 :  (eprop  ( ( (eq A4)  x4)  y4) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_31 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  H欧2)  y4)  H欧2) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_628 :  (etype A1)  ->  (_627 :  (etype A2)  ->  (_626 :  (etype A3)  ->  (_625 :  (etype A4)  ->  (_624 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) , H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  x2)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0) )  -->  (H欧1 :  (eprop  ( ( (eq A3)  x3)  y3) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_30 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  H欧1)  y3)  H欧1) ) .+[A1 : Utype, A2 : Utype, A3 : Utype, A4 : Utype, A5 : Utype, B : Utype, f :  (_604 :  (etype A1)  ->  (_603 :  (etype A2)  ->  (_602 :  (etype A3)  ->  (_601 :  (etype A4)  ->  (_600 :  (etype A5)  ->  (etype B) ) ) ) ) ) , x1 :  (etype A1) , y1 :  (etype A1) , x2 :  (etype A2) , y2 :  (etype A2) , x3 :  (etype A3) , y3 :  (etype A3) , x4 :  (etype A4) , y4 :  (etype A4) , x5 :  (etype A5) , y5 :  (etype A5) , H :  (eprop  ( ( (eq A1)  x1)  y1) ) ]  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  x1)   ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (refl_equal_case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H) )  -->  (H欧0 :  (eprop  ( ( (eq A2)  x2)  y2) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_29 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  H欧0)  y2)  H欧0) ) .+f_equal5 :  (A1 : Utype ->  (A2 : Utype ->  (A3 : Utype ->  (A4 : Utype ->  (A5 : Utype ->  (B : Utype ->  (f :  (_714 :  (etype A1)  ->  (_713 :  (etype A2)  ->  (_712 :  (etype A3)  ->  (_711 :  (etype A4)  ->  (_710 :  (etype A5)  ->  (etype B) ) ) ) ) )  ->  (x1 :  (etype A1)  ->  (y1 :  (etype A1)  ->  (x2 :  (etype A2)  ->  (y2 :  (etype A2)  ->  (x3 :  (etype A3)  ->  (y3 :  (etype A3)  ->  (x4 :  (etype A4)  ->  (y4 :  (etype A4)  ->  (x5 :  (etype A5)  ->  (y5 :  (etype A5)  ->  (_719 :  (eprop  ( ( (eq A1)  x1)  y1) )  ->  (_718 :  (eprop  ( ( (eq A2)  x2)  y2) )  ->  (_717 :  (eprop  ( ( (eq A3)  x3)  y3) )  ->  (_716 :  (eprop  ( ( (eq A4)  x4)  y4) )  ->  (_715 :  (eprop  ( ( (eq A5)  x5)  y5) )  ->  (eprop  ( ( (eq B)   ( ( ( ( (f x1)  x2)  x3)  x4)  x5) )   ( ( ( ( (f y1)  y2)  y3)  y4)  y5) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+[] f_equal5 -->  (A1 :  (etype dottype)  =>  (A2 :  (etype dottype)  =>  (A3 :  (etype dottype)  =>  (A4 :  (etype dottype)  =>  (A5 :  (etype dottype)  =>  (B :  (etype dottype)  =>  (f :  (etype  ( (dotpitt A1)   (_709 :  (etype A1)  =>  ( (dotpitt A2)   (_708 :  (etype A2)  =>  ( (dotpitt A3)   (_707 :  (etype A3)  =>  ( (dotpitt A4)   (_706 :  (etype A4)  =>  ( (dotpitt A5)   (_705 :  (etype A5)  => B) ) ) ) ) ) ) ) ) ) )  =>  (x1 :  (etype A1)  =>  (y1 :  (etype A1)  =>  (x2 :  (etype A2)  =>  (y2 :  (etype A2)  =>  (x3 :  (etype A3)  =>  (y3 :  (etype A3)  =>  (x4 :  (etype A4)  =>  (y4 :  (etype A4)  =>  (x5 :  (etype A5)  =>  (y5 :  (etype A5)  =>  (H :  (eprop  ( ( (eq A1)  x1)  y1) )  =>  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (case_28 A1)  A2)  A3)  A4)  A5)  B)  f)  x1)  y1)  x2)  y2)  x3)  y3)  x4)  y4)  x5)  y5)  H)  y1)  H) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .+subrelation :  (A : Utype ->  (B : Utype ->  (R :  (_726 :  (etype A)  ->  (_725 :  (etype B)  -> Uprop) )  ->  (R' :  (_728 :  (etype A)  ->  (_727 :  (etype B)  -> Uprop) )  -> Uprop) ) ) ) .+[] subrelation -->  (A :  (etype dottype)  =>  (B :  (etype dottype)  =>  (R :  (etype  ( (dotpitt A)   (_724 :  (etype A)  =>  ( (dotpitt B)   (_723 :  (etype B)  => dotprop) ) ) ) )  =>  (R' :  (etype  ( (dotpitt A)   (_722 :  (etype A)  =>  ( (dotpitt B)   (_721 :  (etype B)  => dotprop) ) ) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpitp B)   (y :  (etype B)  =>  ( (dotpipp  ( (R x)  y) )   (_720 :  (eprop  ( (R x)  y) )  =>  ( (R' x)  y) ) ) ) ) ) ) ) ) ) ) .+unique :  (A : Utype ->  (P :  (_731 :  (etype A)  -> Uprop)  ->  (x :  (etype A)  -> Uprop) ) ) .+[] unique -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_730 :  (etype A)  => dotprop) ) )  =>  (x :  (etype A)  =>  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_729 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) ) ) ) .+uniqueness :  (A : Utype ->  (P :  (_735 :  (etype A)  -> Uprop)  -> Uprop) ) .+[] uniqueness -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_734 :  (etype A)  => dotprop) ) )  =>  ( (dotpitp A)   (x :  (etype A)  =>  ( (dotpitp A)   (y :  (etype A)  =>  ( (dotpipp  (P x) )   (_733 :  (eprop  (P x) )  =>  ( (dotpipp  (P y) )   (_732 :  (eprop  (P y) )  =>  ( ( (eq A)  x)  y) ) ) ) ) ) ) ) ) ) ) .+case_33 :  (A : Utype ->  (P :  (_738 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (_739 :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) ) .+conj_case_33 :  (A : Utype ->  (P :  (_741 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (_743 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_742 :  (eprop  ( (uniqueness A)  P) )  ->  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) ) .+[A : Utype, P :  (_744 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ]  ( ( (conj_case_33 A)  P)  H)  -->  ( (conj  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) .+case_34 :  (A : Utype ->  (P :  (_745 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_747 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_746 :  (eprop  ( (uniqueness A)  P) )  ->  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) ) ) ) .+ex_intro_case_34 :  (A : Utype ->  (P :  (_749 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  ->  (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (x :  (etype A)  ->  (_750 :  (eprop  ( (x欧0 :  (etype A)  =>  (P x欧0) )  x) )  ->  (eprop  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_751 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) ]  ( ( ( (ex_intro_case_34 A)  P)  H)  H欧0)  -->  ( (ex_intro A)   (x :  (etype A)  =>  (P x) ) ) .+[A : Utype, P :  (_748 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_25 :  (etype A) , var_26 :  (eprop  ( (x :  (etype A)  =>  (P x) )  var_25) ) ]  ( ( ( ( (case_34 A)  P)  H)  H欧0)   ( ( ( ( ( (ex_intro_case_34 A)  P)  H)  H欧0)  var_25)  var_26) )  -->  ( ( (x :  (etype A)  =>  (Hx :  (eprop  (P x) )  =>  (Huni :  (eprop  ( (uniqueness A)  P) )  =>  ( ( ( (ex_intro A)   ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )  x)   ( ( ( (conj  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_752 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) )  Hx)   (x' :  (etype A)  =>  (H欧1 :  (eprop  (P x') )  =>  ( ( ( (Huni x)  x')  Hx)  H欧1) ) ) ) ) ) ) )  var_25)  var_26) .+[A : Utype, P :  (_740 :  (etype A)  -> Uprop) , H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) , var_23 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_24 :  (eprop  ( (uniqueness A)  P) ) ]  ( ( ( (case_33 A)  P)  H)   ( ( ( ( (conj_case_33 A)  P)  H)  var_23)  var_24) )  -->  ( ( (H欧0 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  =>  ( ( ( ( (case_34 A)  P)  H)  H欧0)  H欧0) )  var_23)  var_24) .+case_35 :  (A : Utype ->  (P :  (_753 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (_754 :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) .+ex_intro_case_35 :  (A : Utype ->  (P :  (_756 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (_757 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (eprop  ( (ex A)   ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_758 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ]  ( ( (ex_intro_case_35 A)  P)  H)  -->  ( (ex_intro A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) .+case_36 :  (A : Utype ->  (P :  (_759 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (_761 :  (eprop  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_760 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) )  ->  (eprop  ( (and  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )   ( (uniqueness A)  P) ) ) ) ) ) ) ) ) .+conj_case_36 :  (A : Utype ->  (P :  (_764 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  ->  (x :  (etype A)  ->  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  ->  (_768 :  (eprop  (P x) )  ->  (_767 :  (x' :  (etype A)  ->  (_765 :  (eprop  (P x') )  ->  (eprop  ( ( (eq A)  x)  x') ) ) )  ->  (eprop  ( (and  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_766 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_769 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , x :  (etype A) , H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) ) ]  ( ( ( ( (conj_case_36 A)  P)  H)  x)  H欧0)  -->  ( (conj  (P x) )   ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_763 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) ) .+[A : Utype, P :  (_762 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , x :  (etype A) , H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) ) , var_29 :  (eprop  (P x) ) , var_30 :  (x' :  (etype A)  ->  (_770 :  (eprop  (P x') )  ->  (eprop  ( ( (eq A)  x)  x') ) ) ) ]  ( ( ( ( ( (case_36 A)  P)  H)  x)  H欧0)   ( ( ( ( ( ( (conj_case_36 A)  P)  H)  x)  H欧0)  var_29)  var_30) )  -->  ( ( (Hx :  (eprop  (P x) )  =>  (Huni :  (eprop  ( (dotpitp A)   (x' :  (etype A)  =>  ( (dotpipp  (P x') )   (_771 :  (eprop  (P x') )  =>  ( ( (eq A)  x)  x') ) ) ) ) )  =>  ( ( ( (conj  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) )   ( (uniqueness A)  P) )   ( ( ( (ex_intro A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x)  Hx) )   (x' :  (etype A)  =>  (x'' :  (etype A)  =>  (Hx' :  (eprop  (P x') )  =>  (Hx'' :  (eprop  (P x'') )  =>  ( ( ( ( ( (trans_eq A)  x')  x)  x'')   ( ( ( (sym_eq A)  x)  x')   ( (Huni x')  Hx') ) )   ( (Huni x'')  Hx'') ) ) ) ) ) ) ) )  var_29)  var_30) .+[A : Utype, P :  (_755 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) , var_27 :  (etype A) , var_28 :  (eprop  ( ( (unique A)   (x :  (etype A)  =>  (P x) ) )  var_27) ) ]  ( ( ( (case_35 A)  P)  H)   ( ( ( ( (ex_intro_case_35 A)  P)  H)  var_27)  var_28) )  -->  ( ( (x :  (etype A)  =>  (H欧0 :  (eprop  ( ( (unique A)   (x欧0 :  (etype A)  =>  (P x欧0) ) )  x) )  =>  ( ( ( ( ( (case_36 A)  P)  H)  x)  H欧0)  H欧0) ) )  var_27)  var_28) .+unique_existence :  (A : Utype ->  (P :  (_773 :  (etype A)  -> Uprop)  ->  (eprop  ( (iff  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )   ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) ) ) .+[] unique_existence -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_772 :  (etype A)  => dotprop) ) )  =>  ( ( ( (conj  ( (dotpipp  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )   (_736 :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  =>  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) ) ) )   ( (dotpipp  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )   (_737 :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  =>  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) ) ) )   (H :  (eprop  ( (and  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )   ( (uniqueness A)  P) ) )  =>  ( ( ( (case_33 A)  P)  H)  H) ) )   (H :  (eprop  ( (ex A)   ( (unique A)   (x :  (etype A)  =>  (P x) ) ) ) )  =>  ( ( ( (case_35 A)  P)  H)  H) ) ) ) ) .+inhabited :  (A : Utype -> Uprop) .+inhabits :  (A : Utype ->  (_774 :  (etype A)  ->  (eprop  (inhabited A) ) ) ) .+case_37 :  (A : Utype ->  (P : Uprop ->  (f :  (_775 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (_776 :  (eprop  (inhabited A) )  ->  (eprop P) ) ) ) ) ) .+inhabits_case_37 :  (A : Utype ->  (P : Uprop ->  (f :  (_778 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (_779 :  (etype A)  ->  (eprop  (inhabited A) ) ) ) ) ) ) .+[A : Utype, P : Uprop, f :  (_780 :  (etype A)  ->  (eprop P) ) , i :  (eprop  (inhabited A) ) ]  ( ( ( (inhabits_case_37 A)  P)  f)  i)  -->  (inhabits A) .+[A : Utype, P : Uprop, f :  (_777 :  (etype A)  ->  (eprop P) ) , i :  (eprop  (inhabited A) ) , var_31 :  (etype A) ]  ( ( ( ( (case_37 A)  P)  f)  i)   ( ( ( ( (inhabits_case_37 A)  P)  f)  i)  var_31) )  -->  (f var_31) .+inhabited_ind :  (A : Utype ->  (P : Uprop ->  (f :  (_782 :  (etype A)  ->  (eprop P) )  ->  (i :  (eprop  (inhabited A) )  ->  (eprop P) ) ) ) ) .+[] inhabited_ind -->  (A :  (etype dottype)  =>  (P :  (etype dotprop)  =>  (f :  (eprop  ( (dotpitp A)   (_781 :  (etype A)  => P) ) )  =>  (i :  (eprop  (inhabited A) )  =>  ( ( ( ( (case_37 A)  P)  f)  i)  i) ) ) ) ) .+case_38 :  (A : Utype ->  (P :  (_783 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (_784 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (eprop  (inhabited A) ) ) ) ) ) .+ex_intro_case_38 :  (A : Utype ->  (P :  (_786 :  (etype A)  -> Uprop)  ->  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (x :  (etype A)  ->  (_787 :  (eprop  ( (x欧0 :  (etype A)  =>  (P x欧0) )  x) )  ->  (eprop  ( (ex A)   (x欧0 :  (etype A)  =>  (P x欧0) ) ) ) ) ) ) ) ) .+[A : Utype, P :  (_788 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) ]  ( ( (ex_intro_case_38 A)  P)  H)  -->  ( (ex_intro A)   (x :  (etype A)  =>  (P x) ) ) .+[A : Utype, P :  (_785 :  (etype A)  -> Uprop) , H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) ) , var_32 :  (etype A) , var_33 :  (eprop  ( (x :  (etype A)  =>  (P x) )  var_32) ) ]  ( ( ( (case_38 A)  P)  H)   ( ( ( ( (ex_intro_case_38 A)  P)  H)  var_32)  var_33) )  -->  ( ( (x :  (etype A)  =>  (H欧0 :  (eprop  (P x) )  =>  ( (inhabits A)  x) ) )  var_32)  var_33) .+exists_inhabited :  (A : Utype ->  (P :  (_790 :  (etype A)  -> Uprop)  ->  (_791 :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  ->  (eprop  (inhabited A) ) ) ) ) .+[] exists_inhabited -->  (A :  (etype dottype)  =>  (P :  (etype  ( (dotpitt A)   (_789 :  (etype A)  => dotprop) ) )  =>  (H :  (eprop  ( (ex A)   (x :  (etype A)  =>  (P x) ) ) )  =>  ( ( ( (case_38 A)  P)  H)  H) ) ) ) .+eq_stepl :  (A : Utype ->  (x :  (etype A)  ->  (y :  (etype A)  ->  (z :  (etype A)  ->  (_793 :  (eprop  ( ( (eq A)  x)  y) )  ->  (_792 :  (eprop  ( ( (eq A)  x)  z) )  ->  (eprop  ( ( (eq A)  z)  y) ) ) ) ) ) ) ) .+[] eq_stepl -->  (A :  (etype dottype)  =>  (x :  (etype A)  =>  (y :  (etype A)  =>  (z :  (etype A)  =>  (H1 :  (eprop  ( ( (eq A)  x)  y) )  =>  (H2 :  (eprop  ( ( (eq A)  x)  z) )  =>  ( ( ( ( ( (eq_ind A)  x)   (z欧0 :  (etype A)  =>  ( ( (eq A)  z欧0)  y) ) )  H1)  z)  H2) ) ) ) ) ) ) .+iff_stepl :  (A : Uprop ->  (B : Uprop ->  (C : Uprop ->  (_805 :  (eprop  ( (iff A)  B) )  ->  (_804 :  (eprop  ( (iff A)  C) )  ->  (eprop  ( (iff C)  B) ) ) ) ) ) ) .+[] iff_stepl -->  (A :  (etype dotprop)  =>  (B :  (etype dotprop)  =>  (C :  (etype dotprop)  =>  (H :  (eprop  ( (iff A)  B) )  =>  (H0 :  (eprop  ( (iff A)  C) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_794 :  (eprop A)  => B) ) )   ( (dotpipp B)   (_795 :  (eprop B)  => A) ) )   ( (iff C)  B) )   (H1 :  (eprop  ( (dotpipp A)   (_803 :  (eprop A)  => B) ) )  =>  (H2 :  (eprop  ( (dotpipp B)   (_802 :  (eprop B)  => A) ) )  =>  ( ( ( ( (and_ind  ( (dotpipp A)   (_796 :  (eprop A)  => C) ) )   ( (dotpipp C)   (_797 :  (eprop C)  => A) ) )   ( (iff C)  B) )   (H欧0 :  (eprop  ( (dotpipp A)   (_801 :  (eprop A)  => C) ) )  =>  (H3 :  (eprop  ( (dotpipp C)   (_800 :  (eprop C)  => A) ) )  =>  ( ( ( (conj  ( (dotpipp C)   (_798 :  (eprop C)  => B) ) )   ( (dotpipp B)   (_799 :  (eprop B)  => C) ) )   (H0欧0 :  (eprop C)  =>  ( (H4 :  (eprop A)  =>  ( (H3欧0 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop A)  => H3欧0)   (H2 H3欧0) ) )   (H欧0 H4) ) )   (H1 H4) ) )   (H3 H0欧0) ) ) )   (H0欧0 :  (eprop B)  =>  ( (H4 :  (eprop A)  =>  ( (H2欧0 :  (eprop B)  =>  ( (H1欧0 :  (eprop C)  =>  ( (H欧1 :  (eprop A)  => H1欧0)   (H3 H1欧0) ) )   (H欧0 H4) ) )   (H1 H4) ) )   (H2 H0欧0) ) ) ) ) ) )  H0) ) ) )  H) ) ) ) ) ) .+;Finished module Logic
+ t/linearity.eu view
@@ -0,0 +1,3 @@+Nat: Type.+Q : (Nat -> Nat) -> Nat -> Nat -> Type.+[a:Nat, f : Nat ->  Nat]  Q f a (f a) --> Nat.
+ t/logic.eu view
@@ -0,0 +1,49 @@+False : coc.Utype.++True : coc.Utype.++I : coc.etype True.++eq : t : coc.Utype -> coc.etype t -> coc.etype t -> Type. ++eq_ : t : coc.Utype -> coc.etype t -> coc.etype t -> coc.Utype. ++[ t : coc.Utype+, x : coc.etype t+, y : coc.etype t ]+eq t x y --> coc.etype (eq_ t x y).+++refl_equal : t : coc.Utype -> x : coc.etype t -> eq t x x.++eq_rec : t : coc.Utype +     -> x : coc.etype t+     -> p : (coc.etype t -> coc.Utype)+     -> g : coc.etype (p x)+     -> y : coc.etype t+     -> h : eq t x y+     -> coc.etype (p y).++[ t : coc.Utype+, x : coc.etype t+, p : coc.etype t -> coc.Utype+, f : coc.etype (p x) ]+eq_rec t x p  f x (refl_equal t x) --> f.++f_equal +     : A : coc.Utype +    -> B : coc.Utype +    -> f : (coc.etype A -> coc.etype B)+    -> x : coc.etype A +    -> y : coc.etype A +    -> H : eq A x y+    -> eq B (f x) (f y).++[] f_equal --> +    A : coc.Utype + => B : coc.Utype + => f : (coc.etype A -> coc.etype B)+ => x : coc.etype A + => y : coc.etype A + => H : eq A x y+ => eq_rec A x  (z : coc.etype A => eq_ B (f x) (f z)) (refl_equal B (f x)) y H.
+ t/loop.eu view
@@ -0,0 +1,4 @@+A : Type.+[] A --> A -> A.+t : A.+[] t --> x : A => x.
+ t/nat.eu view
@@ -0,0 +1,17 @@+nat : Type.++0 : nat.++S : nat -> nat.++1 : nat.++[] 1 --> (S 0).++plus : nat -> nat -> nat.+[x : nat] plus x 0 --> x.+[x : nat] plus 0 x --> x.+[x : nat, y : nat] plus x (S y) --> S (plus x y).+[x : nat, y : nat] plus (S x) y --> S (plus x y).++
+ t/peano.eu view
@@ -0,0 +1,66 @@+nat : Type.++nat_ : coc.Utype.++[] nat --> coc.etype nat_.++0 : nat.++S : nat -> nat.++nat_rec : t : coc.Utype +    -> coc.etype t +    -> (nat -> coc.etype t -> coc.etype t)+    -> nat+    -> coc.etype t.++[ t : coc.Utype+, a : coc.etype t+, f : nat -> coc.etype t -> coc.etype t+] nat_rec t a f 0 --> a.++[ t : coc.Utype+, a : coc.etype t+, f : nat -> coc.etype t -> coc.etype t+, n : nat+] nat_rec t a f (S n) --> f n (nat_rec t a f (S n)).++plus : nat -> nat -> nat.++[] plus --> x : nat => y : nat => nat_rec nat_ 0 (x : nat => y : nat => y) x.++plus2 : nat -> nat -> nat.++[x : nat] plus2 x 0 --> x.+[x : nat] plus2 0 x --> x.+[x : nat, y : nat] plus2 x (S y) --> S (plus2 x y).+[x : nat, y : nat] plus2 (S x) y --> S (plus2 x y).++eq_S : x : nat +    -> y : nat +    -> logic.eq nat_ x y +    -> logic.eq nat_ (S x) (S y).++[] eq_S --> logic.f_equal nat_ nat_ S.++eq_S2 : coc.etype (coc.dotpi1 nat_ (x : nat+    => coc.dotpi1 nat_ (y : nat+    => coc.dotpi1 (logic.eq_ nat_ x y) (h : logic.eq nat_ x y +    => logic.eq_ nat_ (S x) (S y))))).++[] eq_S2 --> eq_S.+++pred : nat -> nat.++[] pred --> nat_rec nat_ 0 (x:nat => nat => x).++pred2 :  nat -> nat.++[] pred2 0 --> 0.++[x : nat] pred2 (S x) --> x.++pred_Sn : n : nat -> logic.eq nat_ n (pred (S n)).++[] pred_Sn --> n : nat => logic.refl_equal nat_ n.
+ t/plus.eu view
@@ -0,0 +1,7 @@+P : nat.nat -> Type.++y : P (nat.S nat.0).++w : P (nat.S nat.0).++[] w --> (x : P (nat.plus nat.0 (nat.S nat.0)) => x) y.
+ t/sigma.eu view
@@ -0,0 +1,41 @@+o : Type.+eps : o -> Type.++sigma_ : A : o -> (eps A -> o) -> o.+exist_ : A : o -> P : (eps A -> o) -> x : eps A -> eps (P x) -> eps (sigma_ A P).++fst : A : o -> P : (eps A -> o) -> eps (sigma_ A P) -> eps A.+[A : o, P : eps A -> o, w : eps A, pi : P w]+fst _ _ (eps (exist_ _ _ w pi)) --> w.++snd : A : o -> P : (eps A -> o) -> s : eps (sigma_ A P) -> eps (P (fst A P s)).+[A : o, P : eps A -> o, w : eps A, pi : P w]+snd _ _ (eps (exist_ _ _ w pi)) --> pi.+++;; test++nat : Type.+nat_ : o.++O : nat.+S : nat -> nat.++plus : nat -> nat -> nat.+[n:nat,m:nat] plus (S n) m --> S (plus n m).+[n:nat,m:nat] plus O m --> m.++eq : nat -> nat -> Type.+[n:nat,m:nat] eq (S n) (S m) --> eq n m.+ax: eq O O.++eq_ : nat -> nat -> o.++[x:nat,y:nat] eps (eq_ x y) --> eq x y.+[] eps nat_ --> nat.++thm : n:nat -> eps (sigma_ nat_ (m:nat => eq_ (plus (S O) n) m)).+[] thm --> n:nat => exist_ nat_ (m:nat => eq_ (plus (S O) n) m) (S n) ax.++verif : eq (fst nat_ (m:nat => eq_ (plus (S O) O) m) (thm O)) (S O).+[] verif --> ax.
+ t/sigma2.eu view
@@ -0,0 +1,31 @@+nat : Type.+0 : nat.+S : nat -> nat.++plus:nat -> nat -> nat.+[x:nat] plus x 0 --> x.+[x:nat] (plus 0) x --> x.+[x:nat, y:nat] plus x (S y) --> S (plus x y).+[x:nat, y:nat] (plus (S x)) y --> S (plus x y).++eqnat : nat -> nat -> Type.+ax: eqnat 0 0.+[n:nat, m:nat] eqnat (S n) (S m) --> eqnat n m.++o : Type.+eps : o -> Type.++_nat : o.+[] (eps _nat) --> nat. ++_eqnat : nat -> nat -> o.+[n:nat,m:nat] eps (_eqnat n m) --> eqnat n m.++[x:o] eps x --> (eps x).++sigma : a:o -> (eps a -> o) -> Type.+++th : Type.+[] th --> sigma _nat (n:nat => _nat).+
+ t/stt1.eu view
@@ -0,0 +1,57 @@+; Simple Type Theory as a theory in predicate logic.+;+; Use reverse polish notation for names, eg:+;   * i -> i becomes iia,+;   * i -> i -> i becomes iiiaa+;   * (i -> i) -> i becomes iiaia++o : Type.+eps : o -> Type.++i : Type.+iia : Type.+iiiaa : Type.+iiiiaaa : Type.+iiaia : Type.+iiiaaiiaiiaaa : Type.+iiaiiaa : Type.++ooa : Type.+oooaa : Type.+ioaoa : Type.+iiaoaoa : Type.+iiiaaoaoa : Type.++O : i.+S : iia.++ap_iia : iia -> i -> i.+ap_iiiaa : iiiaa -> i -> iia.+ap_iiiaaiiaiiaaa : iiiaaiiaiiaaa -> iiiaa -> iiaiiaa.+ap_iiaiiaa : iiaiiaa -> iia -> iia.++ap_ooa : ooa -> o -> o.+ap_oooaa : oooaa -> o -> ooa.++one : i.+[] one --> ap_iia S O.++imp : oooaa.+forall_i : ioaoa.+forall_iia : iiaoaoa.+forall_iiiaa : iiiaaoaoa.++; S and K combinators.+S_iiiaaiiaiiaaa : iiiaaiiaiiaaa.+K_iiiaa : iiiaa.++[ x : iiiaa+, y : iia+, z : i ]+ap_iia (ap_iiaiiaa (ap_iiiaaiiaiiaaa S_iiiaaiiaiiaaa x) y) z --> ap_iia (ap_iiiaa x z) (ap_iia y z).+[ x : i+, y : i ]+ap_iia (ap_iiiaa K_iiiaa x) y --> x.+[ x : o+, y : o ]+eps (ap_ooa (ap_oooaa imp x) y) --> eps x -> eps y.
+ t/test1.eu view
@@ -0,0 +1,8 @@+nat : Type.+0 : nat.+S : nat -> nat.+a : Type.+vec : nat -> Type.+vec' : n : nat -> vec n.+nil : vec 0.+cons : n : nat -> a -> vec n -> vec (S n).
+ t/testcomplet.eu view
@@ -0,0 +1,60 @@+Uset : Type.+Uprop : Type.+Utype : Type.++eprop : x : Uprop -> Type.+eset : x : Uset -> Type.+etype : x : Utype -> Type.++dotset : Utype.+dotprop : Utype.++dotpipp : x : Uprop -> y : (eprop x -> Uprop) -> Uprop.+dotpips : x : Uprop -> y : (eprop x -> Uset)  -> Uset.+dotpipt : x : Uprop -> y : (eprop x -> Utype) -> Utype.+dotpisp : x : Uset  -> y : (eset x  -> Uprop) -> Uprop.+dotpitp : x : Utype -> y : (etype x -> Uprop) -> Uprop.+dotpist : x : Uset  -> y : (eset  x -> Utype) -> Utype.+dotpits : x : Utype -> y : (etype x -> Uset)  -> Uset.+dotpiss : x : Uset  -> y : (eset x  -> Uset)  -> Uset.+dotpitt : x : Utype -> y : (etype x -> Utype) -> Utype.+++[x:Uprop, y : eprop x -> Uprop]+              eprop (dotpipp x y) --> w : eprop x -> eprop (y w).++[x:Uset, y : eset x -> Uprop]+              eprop (dotpisp x y) --> w : eset x -> eprop (y w).++[x:Utype, y : etype x -> Uprop]+              eprop (dotpitp x y) --> w : etype x -> eprop (y w).++[x:Uprop, y : eprop x -> Uset]+              eset (dotpips x y) --> w : eprop x -> eset (y w).++[x:Utype, y : etype x -> Uset]+              eset (dotpits x y) --> w : etype x -> eset (y w).++[x:Uset, y : eset x -> Uset]+              eset (dotpiss x y) --> w : eset x -> eset (y w).++[x:Uset, y : eset x -> Utype]+              etype (dotpist x y) --> w : eset x -> etype (y w).++[x:Utype, y : etype x -> Utype]+              etype (dotpitt x y) --> w : etype x -> etype (y w).++[x:Uprop, y : eprop x -> Utype]+              etype (dotpipt x y) --> w : eprop x -> etype (y w).+++[] (etype dotset)  --> Uset.+[] (etype dotprop) --> Uprop.+simple :  (P : Uprop ->  (_ :  (eprop P)  ->  (eprop P) ) ) .+[] simple -->  (P :  (etype dotprop)  =>  (H :  (eprop P)  => H) ) .+K :  (P : Uprop ->  (Q : Uprop ->  (_ :  (eprop P)  ->  (_ :  (eprop Q)  ->  (eprop P) ) ) ) ) .+[] K -->  (P :  (etype dotprop)  =>  (Q :  (etype dotprop)  =>  (H :  (eprop P)  =>  (H0 :  (eprop Q)  =>  ( (simple P)  H) ) ) ) ) .+S :  (P : Uprop ->  (Q : Uprop ->  (R : Uprop ->  (_ :  (_ :  (eprop P)  ->  (_ :  (eprop Q)  ->  (eprop R) ) )  ->  (_ :  (_ :  (eprop P)  ->  (eprop Q) )  ->  (_ :  (eprop P)  ->  (eprop R) ) ) ) ) ) ) .+[] S -->  (P :  (etype dotprop)  =>  (Q :  (etype dotprop)  =>  (R :  (etype dotprop)  =>  (H :  (eprop  ( (dotpipp P)   (_ :  (eprop P)  =>  ( (dotpipp Q)   (_ :  (eprop Q)  => R) ) ) ) )  =>  (H0 :  (eprop  ( (dotpipp P)   (_ :  (eprop P)  => Q) ) )  =>  (H1 :  (eprop P)  =>  ( (H H1)   (H0 H1) ) ) ) ) ) ) ) .+I :  (P : Uprop ->  (_ :  (eprop P)  ->  (eprop P) ) ) .+[] I -->  (P :  (etype dotprop)  =>  ( ( ( ( (S P)   ( (dotpipp P)   (_ :  (eprop P)  => P) ) )  P)   ( (K P)   ( (dotpipp P)   (_ :  (eprop P)  => P) ) ) )   ( (K P)  P) ) ) .
+ t/vec.eu view
@@ -0,0 +1,21 @@+nat : Type.+O : nat.+S : nat -> nat.++o : Type.++nat_ : nat -> o.++eps : o -> Type.+[n : nat] eps (nat_ n) --> Nat n.++Nat : nat -> Type.+[n : nat] Nat n --> P : (nat -> o) -> eps (P O)+                                   -> (m : nat -> (Nat m) -> eps (P m) -> eps (P (S m)))+                                   -> eps (P n).++one : Nat (S O).+[p : nat -> o, z : eps (p O), s : m : nat -> (Nat m) -> eps (P m) -> eps (P (S m))]+one p z s --> s O z.++;; suc : n : nat -> Nat n -> Nat (S n).