Built with Alectryon, running Coq+SerAPI v8.10.0+0.7.0. Coq sources are in this panel; goals and messages will appear in the other. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus.

(************************************************************************)
(*         *   The Coq Proof Assistant / The Coq Development Team       *)
(*  v      *   INRIA, CNRS and contributors - Copyright 1999-2018       *)
(* <O___,, *       (see CREDITS file for the list of authors)           *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)
(*                              Hurkens.v                               *)
(************************************************************************)

Exploiting Hurkens's paradox [Hurkens95] for system U- so as to derive various contradictory contexts.

The file is divided into various sub-modules which all follow the same structure: a section introduces the contradictory hypotheses and a theorem named paradox concludes the module with a proof of False.

The Generic module contains the actual Hurkens's paradox for a postulated shallow encoding of system U- in Coq. This is an adaptation by Arnaud Spiwack of a previous, more restricted implementation by Herman Geuvers. It is used to derive every other special cases of the paradox in this file.
The NoRetractToImpredicativeUniverse module contains a simple and effective formulation by Herman Geuvers [Geuvers01] of a result by Thierry Coquand [Coquand90]. It states that no impredicative sort can contain a type of which it is a retract. This result implies that Coq with classical logic stated in impredicative Set is inconsistent and that classical logic stated in Prop implies proof-irrelevance (see ClassicalFacts.v)
The NoRetractFromSmallPropositionToProp module is a specialisation of the NoRetractToImpredicativeUniverse module to the case where the impredicative sort is Prop.
The NoRetractToModalProposition module is a strengthening of the NoRetractFromSmallPropositionToProp module. It shows that given a monadic modality (aka closure operator) M, the type of modal propositions (i.e. such that M A → A) cannot be a retract of a modal proposition. It is an example of use of the paradox where the universes of system U- are not mapped to universes of Coq.
The NoRetractToNegativeProp module is the specialisation of the NoRetractFromSmallPropositionToProp module where the modality is double-negation. This result implies that the principle of weak excluded middle (∀ A, ~~A\/~A) implies a weak variant of proof irrelevance.
The NoRetractFromTypeToProp module proves that Prop cannot be a retract of a larger type.
The TypeNeqSmallType module proves that Type is different from any smaller type.
The PropNeqType module proves that Prop is different from any larger Type. It is an instance of the previous result.

References:

[Coquand90] T. Coquand, "Metamathematical Investigations of a Calculus of Constructions", Proceedings of Logic in Computer Science (LICS'90), 1990.
[Hurkens95] A. J. Hurkens, "A simplification of Girard's paradox", Proceedings of the 2nd international conference Typed Lambda-Calculi and Applications (TLCA'95), 1995.
[Geuvers01] H. Geuvers, "Inconsistency of Classical Logic in Type Theory", 2001, revised 2007 (see http://www.cs.ru.nl/~herman/PUBS/newnote.ps.gz).

Set Universe Polymorphism.

(* begin show *)

A modular proof of Hurkens's paradox.

It relies on an axiomatisation of a shallow embedding of system U- (i.e. types of U- are interpreted by types of Coq). The universes are encoded in a style, due to Martin-Löf, where they are given by a set of names and a family El:Name→Type which interprets each name into a type. This allows the encoding of universe to be decoupled from Coq's universes. Dependent products and abstractions are similarly postulated rather than encoded as Coq's dependent products and abstractions.

Module Generic.

(* begin hide *)
(* Notations used in the proof. Hidden in coqdoc. *)

Reserved Notation "'∀₁' x : A , B" (at level 200, x ident, A at level 200,right associativity).
Reserved Notation "A '⟶₁' B" (at level 99, right associativity, B at level 200).
Reserved Notation "'λ₁' x , u" (at level 200, x ident, right associativity).
Reserved Notation "f '·₁' x" (at level 5, left associativity).
Reserved Notation "'∀₂' A , F" (at level 200, A ident, right associativity).
Reserved Notation "'λ₂' x , u" (at level 200, x ident, right associativity).
Reserved Notation "f '·₁' [ A ]" (at level 5, left associativity).
Reserved Notation "'∀₀' x : A , B" (at level 200, x ident, A at level 200,right associativity).
Reserved Notation "A '⟶₀' B" (at level 99, right associativity, B at level 200).
Reserved Notation "'λ₀' x , u" (at level 200, x ident, right associativity).
Reserved Notation "f '·₀' x" (at level 5, left associativity).
Reserved Notation "'∀₀¹' A : U , F" (at level 200, A ident, right associativity).
Reserved Notation "'λ₀¹' x , u" (at level 200, x ident, right associativity).
Reserved Notation "f '·₀' [ A ]" (at level 5, left associativity).

(* end hide *)

Section Paradox.

Axiomatisation of impredicative universes in a Martin-Löf style

System U- has two impredicative universes. In the proof of the paradox they are slightly asymmetric (in particular the reduction rules of the small universe are not needed). Therefore, the axioms are duplicated allowing for a weaker requirement than the actual system U-.

Large universe

Variable U1 : Type.
Variable El1 : U1 -> Type.

Closure by small product

Variable Forall1 : forall u:U1, (El1 u -> U1) -> U1.
  Notation "'∀₁' x : A , B" := (Forall1 A (fun x => B)).
  Notation "A '⟶₁' B" := (Forall1 A (fun _ => B)).
Variable lam1 : forall u B, (forall x:El1 u, El1 (B x)) -> El1 (∀₁ x:u, B x).
  Notation "'λ₁' x , u" := (lam1 _ _ (fun x => u)).
Variable app1 : forall u B (f:El1 (Forall1 u B)) (x:El1 u), El1 (B x).
  Notation "f '·₁' x" := (app1 _ _ f x).
Variable beta1 : forall u B (f:forall x:El1 u, El1 (B x)) x,
                   (λ₁ y, f y) ·₁ x = f x.

Closure by large products

U1 only needs to quantify over itself.

Variable ForallU1 : (U1->U1) -> U1.
  Notation "'∀₂' A , F" := (ForallU1 (fun A => F)).
Variable lamU1 : forall F, (forall A:U1, El1 (F A)) -> El1 (∀₂ A, F A).
  Notation "'λ₂' x , u" := (lamU1 _ (fun x => u)).
Variable appU1 : forall F (f:El1(∀₂ A,F A)) (A:U1), El1 (F A).
  Notation "f '·₁' [ A ]" := (appU1 _ f A).
Variable betaU1 : forall F (f:forall A:U1, El1 (F A)) A,
                    (λ₂ x, f x) ·₁ [ A ] = f A.

Small universe

The small universe is an element of the large one.

Variable u0 : U1.
Notation U0 := (El1 u0).
Variable El0 : U0 -> Type.

Closure by small product

U0 does not need reduction rules

Variable Forall0 : forall u:U0, (El0 u -> U0) -> U0.
  Notation "'∀₀' x : A , B" := (Forall0 A (fun x => B)).
  Notation "A '⟶₀' B" := (Forall0 A (fun _ => B)).
Variable lam0 : forall u B, (forall x:El0 u, El0 (B x)) -> El0 (∀₀ x:u, B x).
  Notation "'λ₀' x , u" := (lam0 _ _ (fun x => u)).
Variable app0 : forall u B (f:El0 (Forall0 u B)) (x:El0 u), El0 (B x).
  Notation "f '·₀' x" := (app0 _ _ f x).

Closure by large products

Variable ForallU0 : forall u:U1, (El1 u->U0) -> U0.
  Notation "'∀₀¹' A : U , F" := (ForallU0 U (fun A => F)).
Variable lamU0 : forall U F, (forall A:El1 U, El0 (F A)) -> El0 (∀₀¹ A:U, F A).
  Notation "'λ₀¹' x , u" := (lamU0 _ _ (fun x => u)).
Variable appU0 : forall U F (f:El0(∀₀¹ A:U,F A)) (A:El1 U), El0 (F A).
  Notation "f '·₀' [ A ]" := (appU0 _ _ f A).

Automating the rewrite rules of our encoding.

Ltac simplify :=
  (* spiwack: ideally we could use [rewrite_strategy] here, but I am a tad
     scared of the idea of depending on setoid rewrite in such a simple
     file. *)
  (repeat rewrite ?beta1, ?betaU1);
  lazy beta.

Ltac simplify_in h :=
  (repeat rewrite ?beta1, ?betaU1 in h);
  lazy beta in h.

Hurkens's paradox.

An inhabitant of U0 standing for False.

Variable F:U0.

Preliminary definitions

Definition V : U1 := ∀₂ A, ((A ⟶₁ u0) ⟶₁ A ⟶₁ u0) ⟶₁ A ⟶₁ u0.
Definition U : U1 := V ⟶₁ u0.

Definition sb (z:El1 V) : El1 V := λ₂ A, λ₁ r, λ₁ a, r ·₁ (z·₁[A]·₁r) ·₁ a.

Definition le (i:El1 (U⟶₁u0)) (x:El1 U) : U0 :=
  x ·₁ (λ₂ A, λ₁ r, λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a)).
Definition le' : El1 ((U⟶₁u0) ⟶₁ U ⟶₁ u0) := λ₁ i, λ₁ x, le i x.
Definition induct (i:El1 (U⟶₁u0)) : U0 :=
  ∀₀¹ x:U, le i x ⟶₀ i ·₁ x.

Definition WF : El1 U := λ₁ z, (induct (z·₁[U] ·₁ le')).
Definition I (x:El1 U) : U0 :=
  (∀₀¹ i:U⟶₁u0, le i x ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)) ⟶₀ F
.

Proof

Lemma Omega : El0 (∀₀¹ i:U⟶₁u0, induct i ⟶₀ i ·₁ WF).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
Proof.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
  refine (λ₀¹ i, λ₀ y, _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y0, f y0) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
El0 i ·₁ WF
  refine (y·₀[_]·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y0, f y0) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
El0 (le i WF)
  unfold le,WF,induct.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y0, f y0) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
El0
  (λ₁ z,
   ∀₀¹ x : U,
   le z ·₁ [U] ·₁ le' x ⟶₀ z ·₁ [U] ·₁ le' ·₁ x)
  ·₁ (λ₂ A,
      λ₁ r, λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a)) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y0, f y0) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
El0
  (∀₀¹ x : U,
   le (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x
   ⟶₀ (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a))
      ·₁ x)
  refine (λ₀¹ x, λ₀ h0, _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) ·₁ x simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0 i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)
  refine (y·₀[_]·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
  unfold le.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)
  ·₁ (λ₂ A,
      λ₁ r, λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a)) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (sb
     (λ₂ A,
      λ₁ r, λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a)))
  ·₁ [U] ·₁ le' ·₁ x
  unfold sb at 1.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (λ₂ A,
   λ₁ r,
   λ₁ a,
   r
   ·₁ ((λ₂ A0,
        λ₁ r0,
        λ₁ a0, i ·₁ (λ₁ v, (sb v) ·₁ [A0] ·₁ r0 ·₁ a0))
       ·₁ [A] ·₁ r) ·₁ a) ·₁ [U] ·₁ le' ·₁ x simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  le'
  ·₁ (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a))
  ·₁ x
  unfold le' at 1.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (λ₁ i0, λ₁ x0, le i0 x0)
  ·₁ (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a))
  ·₁ x simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y0, f y0) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
i:El1 (U ⟶₁ u0)
y:El0 (induct i)
x:El1 U
h0:El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (le (λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
  exact h0.
Qed.

Lemma lemma1 : El0 (induct (λ₁ u, I u)).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 (induct (λ₁ u, I u))
Proof.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 (induct (λ₁ u, I u))
  unfold induct.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 (∀₀¹ x : U, le (λ₁ u, I u) x ⟶₀ (λ₁ u, I u) ·₁ x)
  refine (λ₀¹ x, λ₀ p, _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
El0 (λ₁ u, I u) ·₁ x simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
El0 (I x)
  refine (λ₀ q,_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 F
  assert (El0 (I (λ₁ v, (sb v)·₁[U]·₁le'·₁x))) as h.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 F
  {U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)) generalize (q·₀[λ₁ u, I u]·₀p).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 (λ₁ u, I u) ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x) ->
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)) ->
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
    intros q'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
q':El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
    exact q'. }U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0 F
  refine (h·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i : U ⟶₁ u0,
   le i x
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0
  (∀₀¹ i : U ⟶₁ u0,
   le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)
   ⟶₀ i
      ·₁ (λ₁ v,
          (sb v) ·₁ [U] ·₁ le'
          ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x)))
  refine (λ₀¹ i,_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
El0
  (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)
   ⟶₀ i
      ·₁ (λ₁ v,
          (sb v) ·₁ [U] ·₁ le'
          ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x)))
  refine (λ₀ h', _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0
  i
  ·₁ (λ₁ v,
      (sb v) ·₁ [U] ·₁ le'
      ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x))
  generalize (q·₀[λ₁ y, i ·₁ (λ₁ v, (sb v)·₁[U] ·₁ le' ·₁ y)]).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x
   ⟶₀ (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
      ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)) ->
El0
  i
  ·₁ (λ₁ v,
      (sb v) ·₁ [U] ·₁ le'
      ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x)) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x
   ⟶₀ i
      ·₁ (λ₁ v,
          (sb v) ·₁ [U] ·₁ le'
          ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x))) ->
El0
  i
  ·₁ (λ₁ v,
      (sb v) ·₁ [U] ·₁ le'
      ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x))
  intros q'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
q':El0
  (le
     (λ₁ y,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x
   ⟶₀ i
      ·₁ (λ₁ v,
          (sb v) ·₁ [U] ·₁ le'
          ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x)))
El0
  i
  ·₁ (λ₁ v,
      (sb v) ·₁ [U] ·₁ le'
      ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x))
  refine (q'·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
q':El0
  (le
     (λ₁ y,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x
   ⟶₀ i
      ·₁ (λ₁ v,
          (sb v) ·₁ [U] ·₁ le'
          ·₁ (λ₁ v0, (sb v0) ·₁ [U] ·₁ le' ·₁ x)))
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x) clear q'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0 (le i (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x)
  unfold le at 1 in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x)
  ·₁ (λ₂ A,
      λ₁ r,
      λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a))
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x) simplify_in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  (sb
     (λ₂ A,
      λ₁ r,
      λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a)))
  ·₁ [U] ·₁ le' ·₁ x
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x)
  unfold sb at 1 in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  (λ₂ A,
   λ₁ r,
   λ₁ a,
   r
   ·₁ ((λ₂ A0,
        λ₁ r0,
        λ₁ a0,
        i ·₁ (λ₁ v, (sb v) ·₁ [A0] ·₁ r0 ·₁ a0))
       ·₁ [A] ·₁ r) ·₁ a) ·₁ [U] ·₁ le' ·₁ x
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x) simplify_in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  le'
  ·₁ (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a))
  ·₁ x
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x)
  unfold le' at 1 in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  (λ₁ i0, λ₁ x0, le i0 x0)
  ·₁ (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a))
  ·₁ x
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x) simplify_in h'.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El1 U
p:El0 (le (λ₁ u, I u) x)
q:El0
  (∀₀¹ i0 : U ⟶₁ u0,
   le i0 x
   ⟶₀ i0 ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
h:El0 (I (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ x))
i:El1 (U ⟶₁ u0)
h':El0
  (le
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)) x)
El0
  (le (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)) x)
  exact h'.
Qed.

Lemma lemma2 : El0 ((∀₀¹i:U⟶₁u0, induct i ⟶₀ i·₁WF) ⟶₀ F).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 ((∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF) ⟶₀ F)
Proof.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 ((∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF) ⟶₀ F)
  refine (λ₀ x, _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0 F
  assert (El0 (I WF)) as h.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0 (I WF)
U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
h:El0 (I WF)
El0 F
  {U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0 (I WF) generalize (x·₀[λ₁ u, I u]·₀lemma1).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0 (λ₁ u, I u) ·₁ WF -> El0 (I WF) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0 (I WF) -> El0 (I WF)
    intros q.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
q:El0 (I WF)
El0 (I WF)
    exact q. }U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
h:El0 (I WF)
El0 F
  refine (h·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
h:El0 (I WF)
El0
  (∀₀¹ i : U ⟶₁ u0,
   le i WF ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF)) clear h.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i : U ⟶₁ u0, induct i ⟶₀ i ·₁ WF)
El0
  (∀₀¹ i : U ⟶₁ u0,
   le i WF ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF))
  refine (λ₀¹ i, λ₀ h0, _).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
El0 i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF)
  generalize (x·₀[λ₁ y, i·₁(λ₁ v, (sb v)·₁[U]·₁le'·₁y)]).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
   ⟶₀ (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
      ·₁ WF) ->
El0 i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF) simplify.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF)) ->
El0 i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF)
  intros q.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
q:El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF))
El0 i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF)
  refine (q·₀_).U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
q:El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))
   ⟶₀ i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ WF))
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))) clear q.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0 (le i WF)
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)))
  unfold le in h0.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0
  WF
  ·₁ (λ₂ A,
      λ₁ r,
      λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a))
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))) simplify_in h0.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0
  WF
  ·₁ (λ₂ A,
      λ₁ r,
      λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a))
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)))
  unfold WF in h0.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0
  (λ₁ z, induct z ·₁ [U] ·₁ le')
  ·₁ (λ₂ A,
      λ₁ r,
      λ₁ a, i ·₁ (λ₁ v, (sb v) ·₁ [A] ·₁ r ·₁ a))
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y))) simplify_in h0.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x0 : El1 u, El1 (B x0)) ->
El1 (∀₁ x0 : u, B x0)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x0 : El1 u, El1 (B x0)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x0 : El1 u, El1 (B x0))
  (x0 : El1 u), (λ₁ y, f y) ·₁ x0 = f x0
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x0, f x0) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x0 : El0 u, El0 (B x0)) ->
El0 (∀₀ x0 : u, B x0)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x0 : El0 u, El0 (B x0)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
x:El0 (∀₀¹ i0 : U ⟶₁ u0, induct i0 ⟶₀ i0 ·₁ WF)
i:El1 (U ⟶₁ u0)
h0:El0
  (induct
     (λ₁ a,
      i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ a)))
El0
  (induct
     (λ₁ y, i ·₁ (λ₁ v, (sb v) ·₁ [U] ·₁ le' ·₁ y)))
  exact h0.
Qed.

Theorem paradox : El0 F.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 F
Proof.U1:Type
El1:U1 -> Type
Forall1:forall u : U1, (El1 u -> U1) -> U1
lam1:forall (u : U1) (B : El1 u -> U1),
(forall x : El1 u, El1 (B x)) ->
El1 (∀₁ x : u, B x)
app1:forall (u : U1) (B : El1 u -> U1),
El1 (∀₁ x : u, B x) ->
forall x : El1 u, El1 (B x)
beta1:forall (u : U1) (B : El1 u -> U1)
  (f : forall x : El1 u, El1 (B x))
  (x : El1 u), (λ₁ y, f y) ·₁ x = f x
ForallU1:(U1 -> U1) -> U1
lamU1:forall F0 : U1 -> U1,
(forall A : U1, El1 (F0 A)) ->
El1 (∀₂ A, F0 A)
appU1:forall F0 : U1 -> U1,
El1 (∀₂ A, F0 A) -> forall A : U1, El1 (F0 A)
betaU1:forall (F0 : U1 -> U1)
  (f : forall A : U1, El1 (F0 A)) 
  (A : U1), (λ₂ x, f x) ·₁ [A] = f A
u0:U1
El0:U0 -> Type
Forall0:forall u : U0, (El0 u -> U0) -> U0
lam0:forall (u : U0) (B : El0 u -> U0),
(forall x : El0 u, El0 (B x)) ->
El0 (∀₀ x : u, B x)
app0:forall (u : U0) (B : El0 u -> U0),
El0 (∀₀ x : u, B x) ->
forall x : El0 u, El0 (B x)
ForallU0:forall u : U1, (El1 u -> U0) -> U0
lamU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
(forall A : El1 U0, El0 (F0 A)) ->
El0 (∀₀¹ A : U0, F0 A)
appU0:forall (U0 : U1) (F0 : El1 U0 -> Paradox.U0),
El0 (∀₀¹ A : U0, F0 A) ->
forall A : El1 U0, El0 (F0 A)
F:U0
El0 F
  exact (lemma2·₀Omega).
Qed.

End Paradox.

The paradox tactic can be called as a shortcut to use the paradox.

Ltac paradox h :=
  unshelve (refine ((fun h => _) (paradox _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ))).

End Generic.

Impredicative universes are not retracts.

There can be no retract to an impredicative Coq universe from a smaller type. In this version of the proof, the impredicativity of the universe is postulated with a pair of functions from the universe to its type and back which commute with dependent product in an appropriate way.

Module NoRetractToImpredicativeUniverse.

Section Paradox.

Let      U2    := Type.
Let      U1:U2 := Type.
Variable U0:U1.

U1 is impredicative

Variable u22u1 : U2 -> U1.
Hypothesis u22u1_unit   : forall (c:U2), c -> u22u1 c.

u22u1_counit and u22u1_coherent only apply to dependent product so that the equations happen in the smaller U1 rather than U2. Indeed, it is not generally the case that one can project from a large universe to an impredicative universe and then get back the original type again. It would be too strong a hypothesis to require (in particular, it is not true of Prop). The formulation is reminiscent of the monadic characteristic of the projection from a large type to Prop.

Hypothesis u22u1_counit : forall (F:U1->U1), u22u1 (forall A,F A) -> (forall A,F A).
Hypothesis u22u1_coherent : forall (F:U1 -> U1) (f:forall x:U1, F x) (x:U1), 
                              u22u1_counit _ (u22u1_unit _ f) x = f x.

U0 is a retract of U1

Variable u02u1 : U0 -> U1.
Variable u12u0 : U1 -> U0.
Hypothesis u12u0_unit   : forall (b:U1), b -> u02u1 (u12u0 b).
Hypothesis u12u0_counit : forall (b:U1), u02u1 (u12u0 b) -> b.

Paradox

Theorem paradox : forall F:U1, F.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F : U1 -> U1,
u22u1 (forall A : U1, F A) ->
forall A : U1, F A
u22u1_coherent:forall (F : U1 -> U1)
  (f : forall x : U1, F x) 
  (x : U1),
u22u1_counit F
  (u22u1_unit (forall x0 : U1, F x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
forall F : U1, F
Proof.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F : U1 -> U1,
u22u1 (forall A : U1, F A) ->
forall A : U1, F A
u22u1_coherent:forall (F : U1 -> U1)
  (f : forall x : U1, F x) 
  (x : U1),
u22u1_counit F
  (u22u1_unit (forall x0 : U1, F x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
forall F : U1, F
  intros F.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
F
  Generic.paradox h.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
Type
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
?Goal0 -> Type
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : ?Goal0, (?Goal1 u -> ?Goal0) -> ?Goal0
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
(forall x : ?Goal1 u, ?Goal1 (B x)) ->
?Goal1 (?Goal2 u (fun x : ?Goal1 u => B x))
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
?Goal1 (?Goal2 u B) ->
forall x : ?Goal1 u, ?Goal1 (B x)
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
(?Goal0 -> ?Goal0) -> ?Goal0
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : ?Goal0 -> ?Goal0,
(forall A : ?Goal0, ?Goal1 (F0 A)) ->
?Goal1 (?Goal6 (fun A : ?Goal0 => F0 A))
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : ?Goal0 -> ?Goal0,
?Goal1 (?Goal6 (fun A : ?Goal0 => F0 A)) ->
forall A : ?Goal0, ?Goal1 (F0 A)
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
?Goal0
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
?Goal1 ?Goal10 -> Type
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : ?Goal1 ?Goal10,
(?Goal11 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : ?Goal0,
(?Goal1 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
?Goal1 ?Goal10
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
h:?Goal11 ?Goal18
F
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0)
  (f : forall x : ?Goal1 u, ?Goal1 (B x))
  (x : ?Goal1 u),
?Goal4 u (fun x0 : ?Goal1 u => B x0)
  (?Goal3 u B (fun y : ?Goal1 u => f y)) x = 
f x
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (F0 : ?Goal0 -> ?Goal0)
  (f : forall A : ?Goal0, ?Goal1 (F0 A)) 
  (A : ?Goal0),
?Goal8 F0 (?Goal7 F0 (fun x : ?Goal0 => f x)) A = f A
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
(forall x : ?Goal11 u, ?Goal11 (B x)) ->
?Goal11 (?Goal12 u (fun x : ?Goal11 u => B x))
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
?Goal11 (?Goal12 u B) ->
forall x : ?Goal11 u, ?Goal11 (B x)
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : ?Goal0) (F0 : ?Goal1 U -> ?Goal1 ?Goal10),
(forall A : ?Goal1 U, ?Goal11 (F0 A)) ->
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F0 A))
U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : ?Goal0) (F0 : ?Goal1 U -> ?Goal1 ?Goal10),
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F0 A)) ->
forall A : ?Goal1 U, ?Goal11 (F0 A)

Large universe

  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
Type exact U1.
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
U1 -> Type exact (fun X => X).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : U1, ((fun X : U1 => X) u -> U1) -> U1 cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : U1, (u -> U1) -> U1 exact (fun u F => forall x:u, F x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : (fun X : U1 => X) u -> U1),
(forall x : (fun X : U1 => X) u,
 (fun X : U1 => X) (B x)) ->
(fun X : U1 => X)
  ((fun (u0 : U1) (F0 : u0 -> U1) =>
    forall x : u0, F0 x) u
     (fun x : (fun X : U1 => X) u => B x)) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : u -> U1),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : (fun X : U1 => X) u -> U1),
(fun X : U1 => X)
  ((fun (u0 : U1) (F0 : u0 -> U1) =>
    forall x : u0, F0 x) u B) ->
forall x : (fun X : U1 => X) u,
(fun X : U1 => X) (B x) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : u -> U1),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).

  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
(U1 -> U1) -> U1 cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
(U1 -> U1) -> U1 exact (fun F => u22u1 (forall x, F x)).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : U1 -> U1,
(forall A : U1, (fun X : U1 => X) (F0 A)) ->
(fun X : U1 => X)
  ((fun F1 : U1 -> U1 => u22u1 (forall x : U1, F1 x))
     (fun A : U1 => F0 A)) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : U1 -> U1,
(forall A : U1, F0 A) -> u22u1 (forall x : U1, F0 x) exact (fun _ x => u22u1_unit _ x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : U1 -> U1,
(fun X : U1 => X)
  ((fun F1 : U1 -> U1 => u22u1 (forall x : U1, F1 x))
     (fun A : U1 => F0 A)) ->
forall A : U1, (fun X : U1 => X) (F0 A) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall F0 : U1 -> U1,
u22u1 (forall x : U1, F0 x) -> forall A : U1, F0 A exact (fun _ x => u22u1_counit _ x).

Small universe

  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
U1 exact U0.

The interpretation of the small universe is the image of U0 in U1.

  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
(fun X : U1 => X) U0 -> Type cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
U0 -> Type exact (fun X => u02u1 X).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : (fun X : U1 => X) U0,
((fun X : U0 => u02u1 X) u -> (fun X : U1 => X) U0) ->
(fun X : U1 => X) U0 cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : U0, (u02u1 u -> U0) -> U0 exact (fun u F => u12u0 (forall x:(u02u1 u), u02u1 (F x))).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : U1,
((fun X : U1 => X) u -> (fun X : U1 => X) U0) ->
(fun X : U1 => X) U0 cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall u : U1, (u -> U0) -> U0 exact (fun u F => u12u0 (forall x:u, u02u1 (F x))).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
(fun X : U1 => X) U0 cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
U0 exact (u12u0 F).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
h:(fun X : U0 => u02u1 X) (u12u0 F)
F cbn in h.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
h:u02u1 (u12u0 F)
F
    exact (u12u0_counit _ h).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : (fun X : U1 => X) u -> U1)
  (f : forall x : (fun X : U1 => X) u,
       (fun X : U1 => X) (B x))
  (x : (fun X : U1 => X) u),
(fun (u0 : U1) (B0 : u0 -> U1)
   (x0 : forall x0 : u0, B0 x0) => x0) u
  (fun x0 : (fun X : U1 => X) u => B x0)
  ((fun (u0 : U1) (B0 : u0 -> U1)
      (x0 : forall x0 : u0, B0 x0) => x0) u B
     (fun y : (fun X : U1 => X) u => f y)) x = f x cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U1) (B : u -> U1) (f : forall x : u, B x)
  (x : u), f x = f x easy.
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (F0 : U1 -> U1)
  (f : forall A : U1, (fun X : U1 => X) (F0 A))
  (A : U1),
(fun (F1 : U1 -> U1) (x : u22u1 (forall x : U1, F1 x))
 => u22u1_counit F1 x) F0
  ((fun (F1 : U1 -> U1) (x : forall A0 : U1, F1 A0) =>
    u22u1_unit (forall A0 : U1, F1 A0) x) F0
     (fun x : U1 => f x)) A = f A cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (F0 : U1 -> U1) (f : forall A : U1, F0 A)
  (A : U1),
u22u1_counit F0
  (u22u1_unit (forall A0 : U1, F0 A0)
     (fun x : U1 => f x)) A = f A intros **.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F1 : U1 -> U1,
u22u1 (forall A0 : U1, F1 A0) ->
forall A0 : U1, F1 A0
u22u1_coherent:forall (F1 : U1 -> U1)
  (f0 : forall x : U1, F1 x) 
  (x : U1),
u22u1_counit F1
  (u22u1_unit (forall x0 : U1, F1 x0)
     f0) x = f0 x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
F0:U1 -> U1
f:forall A0 : U1, F0 A0
A:U1
u22u1_counit F0
  (u22u1_unit (forall A0 : U1, F0 A0)
     (fun x : U1 => f x)) A = f A now rewrite u22u1_coherent.
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : (fun X : U1 => X) U0)
  (B : (fun X : U0 => u02u1 X) u ->
       (fun X : U1 => X) U0),
(forall x : (fun X : U0 => u02u1 X) u,
 (fun X : U0 => u02u1 X) (B x)) ->
(fun X : U0 => u02u1 X)
  ((fun (u0 : U0) (F0 : u02u1 u0 -> U0) =>
    u12u0 (forall x : u02u1 u0, u02u1 (F0 x))) u
     (fun x : (fun X : U0 => u02u1 X) u => B x)) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U0) (B : u02u1 u -> U0),
(forall x : u02u1 u, u02u1 (B x)) ->
u02u1 (u12u0 (forall x : u02u1 u, u02u1 (B x))) intros * x.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x0 : U1, F0 x0)
  (x0 : U1),
u22u1_counit F0
  (u22u1_unit (forall x1 : U1, F0 x1)
     f) x0 = f x0
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
u:U0
B:u02u1 u -> U0
x:forall x0 : u02u1 u, u02u1 (B x0)
u02u1 (u12u0 (forall x0 : u02u1 u, u02u1 (B x0))) exact (u12u0_unit _ x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : (fun X : U1 => X) U0)
  (B : (fun X : U0 => u02u1 X) u ->
       (fun X : U1 => X) U0),
(fun X : U0 => u02u1 X)
  ((fun (u0 : U0) (F0 : u02u1 u0 -> U0) =>
    u12u0 (forall x : u02u1 u0, u02u1 (F0 x))) u B) ->
forall x : (fun X : U0 => u02u1 X) u,
(fun X : U0 => u02u1 X) (B x) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (u : U0) (B : u02u1 u -> U0),
u02u1 (u12u0 (forall x : u02u1 u, u02u1 (B x))) ->
forall x : u02u1 u, u02u1 (B x) intros * x.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x0 : U1, F0 x0)
  (x0 : U1),
u22u1_counit F0
  (u22u1_unit (forall x1 : U1, F0 x1)
     f) x0 = f x0
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
u:U0
B:u02u1 u -> U0
x:u02u1 (u12u0 (forall x0 : u02u1 u, u02u1 (B x0)))
forall x0 : u02u1 u, u02u1 (B x0) exact (u12u0_counit _ x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : U1)
  (F0 : (fun X : U1 => X) U -> (fun X : U1 => X) U0),
(forall A : (fun X : U1 => X) U,
 (fun X : U0 => u02u1 X) (F0 A)) ->
(fun X : U0 => u02u1 X)
  ((fun (u : U1) (F1 : u -> U0) =>
    u12u0 (forall x : u, u02u1 (F1 x))) U
     (fun A : (fun X : U1 => X) U => F0 A)) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : U1) (F0 : U -> U0),
(forall A : U, u02u1 (F0 A)) ->
u02u1 (u12u0 (forall x : U, u02u1 (F0 x))) intros * x.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F1 : U1 -> U1,
u22u1 (forall A : U1, F1 A) ->
forall A : U1, F1 A
u22u1_coherent:forall (F1 : U1 -> U1)
  (f : forall x0 : U1, F1 x0)
  (x0 : U1),
u22u1_counit F1
  (u22u1_unit (forall x1 : U1, F1 x1)
     f) x0 = f x0
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F, U:U1
F0:U -> U0
x:forall A : U, u02u1 (F0 A)
u02u1 (u12u0 (forall x0 : U, u02u1 (F0 x0))) exact (u12u0_unit _ x).
  +U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : U1)
  (F0 : (fun X : U1 => X) U -> (fun X : U1 => X) U0),
(fun X : U0 => u02u1 X)
  ((fun (u : U1) (F1 : u -> U0) =>
    u12u0 (forall x : u, u02u1 (F1 x))) U
     (fun A : (fun X : U1 => X) U => F0 A)) ->
forall A : (fun X : U1 => X) U,
(fun X : U0 => u02u1 X) (F0 A) cbn.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F0 : U1 -> U1,
u22u1 (forall A : U1, F0 A) ->
forall A : U1, F0 A
u22u1_coherent:forall (F0 : U1 -> U1)
  (f : forall x : U1, F0 x) 
  (x : U1),
u22u1_counit F0
  (u22u1_unit (forall x0 : U1, F0 x0)
     f) x = f x
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F:U1
forall (U : U1) (F0 : U -> U0),
u02u1 (u12u0 (forall x : U, u02u1 (F0 x))) ->
forall A : U, u02u1 (F0 A) intros * x.U2:=Type:Type
U1:=Type:U2
U0:U1
u22u1:U2 -> U1
u22u1_unit:forall c : U2, c -> u22u1 c
u22u1_counit:forall F1 : U1 -> U1,
u22u1 (forall A : U1, F1 A) ->
forall A : U1, F1 A
u22u1_coherent:forall (F1 : U1 -> U1)
  (f : forall x0 : U1, F1 x0)
  (x0 : U1),
u22u1_counit F1
  (u22u1_unit (forall x1 : U1, F1 x1)
     f) x0 = f x0
u02u1:U0 -> U1
u12u0:U1 -> U0
u12u0_unit:forall b : U1, b -> u02u1 (u12u0 b)
u12u0_counit:forall b : U1, u02u1 (u12u0 b) -> b
F, U:U1
F0:U -> U0
x:u02u1 (u12u0 (forall x0 : U, u02u1 (F0 x0)))
forall A : U, u02u1 (F0 A) exact (u12u0_counit _ x).
Qed.

End Paradox.

End NoRetractToImpredicativeUniverse.

Modal fragments of Prop are not retracts

In presence of a a monadic modality on Prop, we can define a subset of Prop of modal propositions which is also a complete Heyting algebra. These cannot be a retract of a modal proposition. This is a case where the universe in system U- are not encoded as Coq universes.

Module NoRetractToModalProposition.

Monadic modality

Section Paradox.

Variable M : Prop -> Prop.
Hypothesis incr : forall A B:Prop, (A->B) -> M A -> M B.

Lemma strength: forall A (P:A->Prop), M(forall x:A,P x) -> forall x:A,M(P x).M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
forall (A : Type) (P : A -> Prop),
M (forall x : A, P x) -> forall x : A, M (P x)
Proof.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
forall (A : Type) (P : A -> Prop),
M (forall x : A, P x) -> forall x : A, M (P x)
  intros A P h x.M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> Prop
h:M (forall x0 : A, P x0)
x:A
M (P x)
  eapply incr in h; eauto.
Qed.

The universe of modal propositions

Definition MProp := { P:Prop | M P -> P }.
Definition El : MProp -> Prop := @proj1_sig _ _.

Lemma modal : forall P:MProp, M(El P) -> El P.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
forall P : MProp, M (El P) -> El P
Proof.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
forall P : MProp, M (El P) -> El P
  intros [P m].M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
P:Prop
m:M P -> P
M (El (exist (fun P0 : Prop => M P0 -> P0) P m)) ->
El (exist (fun P0 : Prop => M P0 -> P0) P m) cbn.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
P:Prop
m:M P -> P
M P -> P
  exact m.
Qed.

Definition Forall {A:Type} (P:A->MProp) : MProp.M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
MProp
Proof.M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
MProp
  unshelve (refine (exist _ _ _)).M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
Prop
M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
M ?Goal -> ?Goal
  +M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
Prop exact (forall x:A, El (P x)).
  +M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
M (forall x : A, El (P x)) -> forall x : A, El (P x) intros h x.M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
h:M (forall x0 : A, El (P x0))
x:A
El (P x)
    eapply strength in h.M:Prop -> Prop
incr:forall A0 B : Prop, (A0 -> B) -> M A0 -> M B
A:Type
P:A -> MProp
x:A
h:M (El (P ?x))
El (P x)
    eauto using modal.
Defined.

Retract of the modal fragment of Prop in a small type

The retract is axiomatized using logical equivalence as the equality on propositions.

Variable bool : MProp.
Variable p2b : MProp -> El bool.
Variable b2p : El bool -> MProp.
Hypothesis p2p1 : forall A:MProp, El (b2p (p2b A)) -> El A.
Hypothesis p2p2 : forall A:MProp, El A -> El (b2p (p2b A)).

Paradox

Theorem paradox : forall B:MProp, El B.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
forall B : MProp, El B
Proof.M:Prop -> Prop
incr:forall A B : Prop, (A -> B) -> M A -> M B
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
forall B : MProp, El B
  intros B.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
El B
  Generic.paradox h.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
Type
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
?Goal0 -> Type
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : ?Goal0, (?Goal1 u -> ?Goal0) -> ?Goal0
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : ?Goal0) (B0 : ?Goal1 u -> ?Goal0),
(forall x : ?Goal1 u, ?Goal1 (B0 x)) ->
?Goal1 (?Goal2 u (fun x : ?Goal1 u => B0 x))
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : ?Goal0) (B0 : ?Goal1 u -> ?Goal0),
?Goal1 (?Goal2 u B0) ->
forall x : ?Goal1 u, ?Goal1 (B0 x)
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
(?Goal0 -> ?Goal0) -> ?Goal0
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : ?Goal0 -> ?Goal0,
(forall A : ?Goal0, ?Goal1 (F A)) ->
?Goal1 (?Goal6 (fun A : ?Goal0 => F A))
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : ?Goal0 -> ?Goal0,
?Goal1 (?Goal6 (fun A : ?Goal0 => F A)) ->
forall A : ?Goal0, ?Goal1 (F A)
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
?Goal0
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
?Goal1 ?Goal10 -> Type
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : ?Goal1 ?Goal10,
(?Goal11 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : ?Goal0,
(?Goal1 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
?Goal1 ?Goal10
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
h:?Goal11 ?Goal18
El B
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : ?Goal0) (B0 : ?Goal1 u -> ?Goal0)
  (f : forall x : ?Goal1 u, ?Goal1 (B0 x))
  (x : ?Goal1 u),
?Goal4 u (fun x0 : ?Goal1 u => B0 x0)
  (?Goal3 u B0 (fun y : ?Goal1 u => f y)) x = 
f x
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (F : ?Goal0 -> ?Goal0)
  (f : forall A : ?Goal0, ?Goal1 (F A)) 
  (A : ?Goal0),
?Goal8 F (?Goal7 F (fun x : ?Goal0 => f x)) A = f A
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : ?Goal1 ?Goal10)
  (B0 : ?Goal11 u -> ?Goal1 ?Goal10),
(forall x : ?Goal11 u, ?Goal11 (B0 x)) ->
?Goal11 (?Goal12 u (fun x : ?Goal11 u => B0 x))
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : ?Goal1 ?Goal10)
  (B0 : ?Goal11 u -> ?Goal1 ?Goal10),
?Goal11 (?Goal12 u B0) ->
forall x : ?Goal11 u, ?Goal11 (B0 x)
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : ?Goal0) (F : ?Goal1 U -> ?Goal1 ?Goal10),
(forall A : ?Goal1 U, ?Goal11 (F A)) ->
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F A))
M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : ?Goal0) (F : ?Goal1 U -> ?Goal1 ?Goal10),
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F A)) ->
forall A : ?Goal1 U, ?Goal11 (F A)

Large universe

  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
Type exact MProp.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
MProp -> Type exact El.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : MProp, (El u -> MProp) -> MProp exact (fun _ => Forall).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp),
(forall x : El u, El (B0 x)) ->
El
  ((fun u0 : MProp => Forall) u (fun x : El u => B0 x)) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp),
(forall x : El u, El (B0 x)) ->
forall x : El u, El (B0 x) exact (fun _ _ f => f).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp),
El ((fun u0 : MProp => Forall) u B0) ->
forall x : El u, El (B0 x) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp),
(forall x : El u, El (B0 x)) ->
forall x : El u, El (B0 x) exact (fun _ _ f => f).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
(MProp -> MProp) -> MProp exact Forall.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : MProp -> MProp,
(forall A : MProp, El (F A)) ->
El (Forall (fun A : MProp => F A)) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : MProp -> MProp,
(forall A : MProp, El (F A)) ->
forall x : MProp, El (F x) exact (fun _ f => f).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : MProp -> MProp,
El (Forall (fun A : MProp => F A)) ->
forall A : MProp, El (F A) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall F : MProp -> MProp,
(forall x : MProp, El (F x)) ->
forall A : MProp, El (F A) exact (fun _ f => f).

Small universe

  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
MProp exact bool.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
El bool -> Type exact (fun b => El (b2p b)).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : El bool,
((fun b : El bool => El (b2p b)) u -> El bool) ->
El bool cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : El bool, (El (b2p u) -> El bool) -> El bool exact (fun _ F => p2b (Forall (fun x => b2p (F x)))).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall u : MProp, (El u -> El bool) -> El bool exact (fun _ F => p2b (Forall (fun x => b2p (F x)))).
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
El bool apply p2b.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
MProp
    exact B.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
h:(fun b : El bool => El (b2p b)) (p2b B)
El B cbn in h.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
h:El (b2p (p2b B))
El B auto.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp)
  (f : forall x : El u, El (B0 x)) (x : El u),
(fun (u0 : MProp) (B1 : El u0 -> MProp)
   (f0 : forall x0 : El u0, El (B1 x0)) => f0) u
  (fun x0 : El u => B0 x0)
  ((fun (u0 : MProp) (B1 : El u0 -> MProp)
      (f0 : forall x0 : El u0, El (B1 x0)) => f0) u B0
     (fun y : El u => f y)) x = f x cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : MProp) (B0 : El u -> MProp)
  (f : forall x : El u, El (B0 x)) (x : El u),
f x = f x easy.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (F : MProp -> MProp)
  (f : forall A : MProp, El (F A)) (A : MProp),
(fun (F0 : MProp -> MProp)
   (f0 : forall x : MProp, El (F0 x)) => f0) F
  ((fun (F0 : MProp -> MProp)
      (f0 : forall A0 : MProp, El (F0 A0)) => f0) F
     (fun x : MProp => f x)) A = f A cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (F : MProp -> MProp)
  (f : forall A : MProp, El (F A)) (A : MProp),
f A = f A easy.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : El bool)
  (B0 : (fun b : El bool => El (b2p b)) u -> El bool),
(forall x : (fun b : El bool => El (b2p b)) u,
 (fun b : El bool => El (b2p b)) (B0 x)) ->
(fun b : El bool => El (b2p b))
  ((fun (u0 : El bool) (F : El (b2p u0) -> El bool) =>
    p2b (Forall (fun x : El (b2p u0) => b2p (F x)))) u
     (fun x : (fun b : El bool => El (b2p b)) u =>
      B0 x)) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : El bool) (B0 : El (b2p u) -> El bool),
(forall x : El (b2p u), El (b2p (B0 x))) ->
El
  (b2p
     (p2b (Forall (fun x : El (b2p u) => b2p (B0 x))))) auto.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : El bool)
  (B0 : (fun b : El bool => El (b2p b)) u -> El bool),
(fun b : El bool => El (b2p b))
  ((fun (u0 : El bool) (F : El (b2p u0) -> El bool) =>
    p2b (Forall (fun x : El (b2p u0) => b2p (F x)))) u
     B0) ->
forall x : (fun b : El bool => El (b2p b)) u,
(fun b : El bool => El (b2p b)) (B0 x) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (u : El bool) (B0 : El (b2p u) -> El bool),
El
  (b2p
     (p2b (Forall (fun x : El (b2p u) => b2p (B0 x))))) ->
forall x : El (b2p u), El (b2p (B0 x)) intros * f.M:Prop -> Prop
incr:forall A B1 : Prop, (A -> B1) -> M A -> M B1
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
u:El bool
B0:El (b2p u) -> El bool
f:El
  (b2p
     (p2b
        (Forall (fun x : El (b2p u) => b2p (B0 x)))))
forall x : El (b2p u), El (b2p (B0 x))
    apply p2p1 in f.M:Prop -> Prop
incr:forall A B1 : Prop, (A -> B1) -> M A -> M B1
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
u:El bool
B0:El (b2p u) -> El bool
f:El (Forall (fun x : El (b2p u) => b2p (B0 x)))
forall x : El (b2p u), El (b2p (B0 x)) cbn in f.M:Prop -> Prop
incr:forall A B1 : Prop, (A -> B1) -> M A -> M B1
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
u:El bool
B0:El (b2p u) -> El bool
f:forall x : El (b2p u), El (b2p (B0 x))
forall x : El (b2p u), El (b2p (B0 x))
    exact f.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : MProp) (F : El U -> El bool),
(forall A : El U,
 (fun b : El bool => El (b2p b)) (F A)) ->
(fun b : El bool => El (b2p b))
  ((fun (u : MProp) (F0 : El u -> El bool) =>
    p2b (Forall (fun x : El u => b2p (F0 x)))) U
     (fun A : El U => F A)) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : MProp) (F : El U -> El bool),
(forall A : El U, El (b2p (F A))) ->
El (b2p (p2b (Forall (fun x : El U => b2p (F x))))) auto.
  +M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : MProp) (F : El U -> El bool),
(fun b : El bool => El (b2p b))
  ((fun (u : MProp) (F0 : El u -> El bool) =>
    p2b (Forall (fun x : El u => b2p (F0 x)))) U
     (fun A : El U => F A)) ->
forall A : El U, (fun b : El bool => El (b2p b)) (F A) cbn.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B:MProp
forall (U : MProp) (F : El U -> El bool),
El (b2p (p2b (Forall (fun x : El U => b2p (F x))))) ->
forall A : El U, El (b2p (F A)) intros * f.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B, U:MProp
F:El U -> El bool
f:El
  (b2p (p2b (Forall (fun x : El U => b2p (F x)))))
forall A : El U, El (b2p (F A))
    apply p2p1 in f.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B, U:MProp
F:El U -> El bool
f:El (Forall (fun x : El U => b2p (F x)))
forall A : El U, El (b2p (F A)) cbn in f.M:Prop -> Prop
incr:forall A B0 : Prop, (A -> B0) -> M A -> M B0
bool:MProp
p2b:MProp -> El bool
b2p:El bool -> MProp
p2p1:forall A : MProp, El (b2p (p2b A)) -> El A
p2p2:forall A : MProp, El A -> El (b2p (p2b A))
B, U:MProp
F:El U -> El bool
f:forall x : El U, El (b2p (F x))
forall A : El U, El (b2p (F A))
    exact f.
Qed.

End Paradox.

End NoRetractToModalProposition.

The negative fragment of Prop is not a retract

The existence in the pure Calculus of Constructions of a retract from the negative fragment of Prop into a negative proposition is inconsistent. This is an instance of the previous result.

Module NoRetractToNegativeProp.

The universe of negative propositions.

Definition NProp := { P:Prop | ~~P -> P }.
Definition El : NProp -> Prop := @proj1_sig _ _.

Section Paradox.

Retract of the negative fragment of Prop in a small type

The retract is axiomatized using logical equivalence as the equality on propositions.

Variable bool : NProp.
Variable p2b : NProp -> El bool.
Variable b2p : El bool -> NProp.
Hypothesis p2p1 : forall A:NProp, El (b2p (p2b A)) -> El A.
Hypothesis p2p2 : forall A:NProp, El A -> El (b2p (p2b A)).

Paradox

Theorem paradox : forall B:NProp, El B.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
forall B : NProp, El B
Proof.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
forall B : NProp, El B
  intros B.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
El B
  unshelve (refine ((fun h => _) (NoRetractToModalProposition.paradox _ _ _ _ _ _ _ _))).bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
Prop -> Prop
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0 ->
NoRetractToModalProposition.El ?Goal0 ?Goal2
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.El ?Goal0 ?Goal2 ->
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
h:NoRetractToModalProposition.El ?Goal0 ?Goal7
El B
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop, (A -> B0) -> ?Goal0 A -> ?Goal0 B0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A : NoRetractToModalProposition.MProp ?Goal0,
NoRetractToModalProposition.El 
  ?Goal0 (?Goal4 (?Goal3 A)) ->
NoRetractToModalProposition.El ?Goal0 A
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A : NoRetractToModalProposition.MProp ?Goal0,
NoRetractToModalProposition.El ?Goal0 A ->
NoRetractToModalProposition.El 
  ?Goal0 (?Goal4 (?Goal3 A))
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
Prop -> Prop exact (fun P => ~~P).
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp
  (fun P : Prop => ~ ~ P) exact bool.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp
  (fun P : Prop => ~ ~ P) ->
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  bool exact p2b.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  bool ->
NoRetractToModalProposition.MProp
  (fun P : Prop => ~ ~ P) exact b2p.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp
  (fun P : Prop => ~ ~ P) exact B.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
h:NoRetractToModalProposition.El
  (fun P : Prop => ~ ~ P) B
El B exact h.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop,
(A -> B0) ->
(fun P : Prop => ~ ~ P) A ->
(fun P : Prop => ~ ~ P) B0 cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop, (A -> B0) -> ~ ~ A -> ~ ~ B0 auto.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => ~ ~ P),
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  (b2p (p2b A)) ->
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  A cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => ~ ~ P),
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  (b2p (p2b A)) ->
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  A auto.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => ~ ~ P),
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  A ->
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  (b2p (p2b A)) cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => ~ ~ P),
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  A ->
NoRetractToModalProposition.El (fun P : Prop => ~ ~ P)
  (b2p (p2b A)) auto.
Qed.

End Paradox.

End NoRetractToNegativeProp.

Prop is not a retract

The existence in the pure Calculus of Constructions of a retract from Prop into a small type of Prop is inconsistent. This is a special case of the previous result.

Module NoRetractFromSmallPropositionToProp.

The universe of propositions.

Definition NProp := { P:Prop | P -> P}.
Definition El : NProp -> Prop := @proj1_sig _ _.

Section MParadox.

Retract of Prop in a small type, using the identity modality.

Variable bool : NProp.
Variable p2b : NProp -> El bool.
Variable b2p : El bool -> NProp.
Hypothesis p2p1 : forall A:NProp, El (b2p (p2b A)) -> El A.
Hypothesis p2p2 : forall A:NProp, El A -> El (b2p (p2b A)).

Paradox

Theorem mparadox : forall B:NProp, El B.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
forall B : NProp, El B
Proof.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
forall B : NProp, El B
  intros B.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
El B
  unshelve (refine ((fun h => _) (NoRetractToModalProposition.paradox _ _ _ _ _ _ _ _))).bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
Prop -> Prop
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0 ->
NoRetractToModalProposition.El ?Goal0 ?Goal2
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.El ?Goal0 ?Goal2 ->
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp ?Goal0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
h:NoRetractToModalProposition.El ?Goal0 ?Goal7
El B
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop, (A -> B0) -> ?Goal0 A -> ?Goal0 B0
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A : NoRetractToModalProposition.MProp ?Goal0,
NoRetractToModalProposition.El 
  ?Goal0 (?Goal4 (?Goal3 A)) ->
NoRetractToModalProposition.El ?Goal0 A
bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A : NoRetractToModalProposition.MProp ?Goal0,
NoRetractToModalProposition.El ?Goal0 A ->
NoRetractToModalProposition.El 
  ?Goal0 (?Goal4 (?Goal3 A))
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
Prop -> Prop exact (fun P => P).
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp (fun P : Prop => P) exact bool.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp (fun P : Prop => P) ->
NoRetractToModalProposition.El (fun P : Prop => P)
  bool exact p2b.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.El (fun P : Prop => P)
  bool ->
NoRetractToModalProposition.MProp (fun P : Prop => P) exact b2p.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
NoRetractToModalProposition.MProp (fun P : Prop => P) exact B.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
h:NoRetractToModalProposition.El 
  (fun P : Prop => P) B
El B exact h.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop,
(A -> B0) ->
(fun P : Prop => P) A -> (fun P : Prop => P) B0 cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall A B0 : Prop, (A -> B0) -> A -> B0 auto.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => P),
NoRetractToModalProposition.El (fun P : Prop => P)
  (b2p (p2b A)) ->
NoRetractToModalProposition.El (fun P : Prop => P) A cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => P),
NoRetractToModalProposition.El (fun P : Prop => P)
  (b2p (p2b A)) ->
NoRetractToModalProposition.El (fun P : Prop => P) A auto.
  +bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => P),
NoRetractToModalProposition.El (fun P : Prop => P) A ->
NoRetractToModalProposition.El (fun P : Prop => P)
  (b2p (p2b A)) cbn.bool:NProp
p2b:NProp -> El bool
b2p:El bool -> NProp
p2p1:forall A : NProp, El (b2p (p2b A)) -> El A
p2p2:forall A : NProp, El A -> El (b2p (p2b A))
B:NProp
forall
  A : NoRetractToModalProposition.MProp
        (fun P : Prop => P),
NoRetractToModalProposition.El (fun P : Prop => P) A ->
NoRetractToModalProposition.El (fun P : Prop => P)
  (b2p (p2b A)) auto.
Qed.

End MParadox.

Section Paradox.

Retract of Prop in a small type

The retract is axiomatized using logical equivalence as the equality on propositions.

Variable bool : Prop.
Variable p2b : Prop -> bool.
Variable b2p : bool -> Prop.
Hypothesis p2p1 : forall A:Prop, b2p (p2b A) -> A.
Hypothesis p2p2 : forall A:Prop, A -> b2p (p2b A).

Paradox

Theorem paradox : forall B:Prop, B.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
forall B : Prop, B
Proof.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
forall B : Prop, B
  intros B.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
B
  unshelve (refine (mparadox (exist _ bool (fun x => x)) _ _ _ _
                   (exist _ B (fun x => x)))).bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
NProp ->
El
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x))
bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
El
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x)) -> NProp
bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp, El (?Goal0 (?Goal A)) -> El A
bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp, El A -> El (?Goal0 (?Goal A))
  +bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
NProp ->
El
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x)) intros p.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
p:NProp
El
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x)) red.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
p:NProp
proj1_sig
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x)) red.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
p:NProp
bool exact (p2b (El p)).
  +bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
El
  (exist (fun x : Prop => x -> x) bool
     (fun x : bool => x)) -> NProp cbn.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
bool -> NProp intros b.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
b:bool
NProp red.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
b:bool
{P : Prop | P -> P} exists (b2p b).bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
b:bool
b2p b -> b2p b exact (fun x => x).
  +bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp,
El
  ((fun b : bool =>
    exist (fun P : Prop => P -> P) (b2p b)
      (fun x : b2p b => x))
     ((fun p : NProp => p2b (El p)) A)) -> El A cbn.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp, b2p (p2b (El A)) -> El A intros [A H].bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A0 : Prop, b2p (p2b A0) -> A0
p2p2:forall A0 : Prop, A0 -> b2p (p2b A0)
B, A:Prop
H:A -> A
b2p (p2b (El (exist (fun P : Prop => P -> P) A H))) ->
El (exist (fun P : Prop => P -> P) A H) cbn.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A0 : Prop, b2p (p2b A0) -> A0
p2p2:forall A0 : Prop, A0 -> b2p (p2b A0)
B, A:Prop
H:A -> A
b2p (p2b A) -> A apply p2p1.
  +bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp,
El A ->
El
  ((fun b : bool =>
    exist (fun P : Prop => P -> P) (b2p b)
      (fun x : b2p b => x))
     ((fun p : NProp => p2b (El p)) A)) cbn.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A : Prop, b2p (p2b A) -> A
p2p2:forall A : Prop, A -> b2p (p2b A)
B:Prop
forall A : NProp, El A -> b2p (p2b (El A)) intros [A H].bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A0 : Prop, b2p (p2b A0) -> A0
p2p2:forall A0 : Prop, A0 -> b2p (p2b A0)
B, A:Prop
H:A -> A
El (exist (fun P : Prop => P -> P) A H) ->
b2p (p2b (El (exist (fun P : Prop => P -> P) A H))) cbn.bool:Prop
p2b:Prop -> bool
b2p:bool -> Prop
p2p1:forall A0 : Prop, b2p (p2b A0) -> A0
p2p2:forall A0 : Prop, A0 -> b2p (p2b A0)
B, A:Prop
H:A -> A
A -> b2p (p2b A) apply p2p2.
Qed.

End Paradox.

End NoRetractFromSmallPropositionToProp.

Large universes are not retracts of Prop.

The existence in the Calculus of Constructions with universes of a retract from some Type universe into Prop is inconsistent.

(* Note: Assuming the context [down:Type->Prop; up:Prop->Type; forth:
      forall (A:Type), A -> up (down A); back: forall (A:Type), up
      (down A) -> A; H: forall (A:Type) (P:A->Type) (a:A),
      P (back A (forth A a)) -> P a] is probably enough.  *)

Module NoRetractFromTypeToProp.

Definition Type2 := Type.
Definition Type1 := Type : Type2.

Section Paradox.

Assumption of a retract from Type into Prop

Variable down : Type1 -> Prop.
Variable up : Prop -> Type1.
Hypothesis up_down : forall (A:Type1), up (down A) = A :> Type1.

Paradox

Theorem paradox : forall P:Prop, P.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
forall P : Prop, P
Proof.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
forall P : Prop, P
  intros P.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
P
  Generic.paradox h.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Type
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
?Goal0 -> Type
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : ?Goal0, (?Goal1 u -> ?Goal0) -> ?Goal0
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
(forall x : ?Goal1 u, ?Goal1 (B x)) ->
?Goal1 (?Goal2 u (fun x : ?Goal1 u => B x))
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
?Goal1 (?Goal2 u B) ->
forall x : ?Goal1 u, ?Goal1 (B x)
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
(?Goal0 -> ?Goal0) -> ?Goal0
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : ?Goal0 -> ?Goal0,
(forall A : ?Goal0, ?Goal1 (F A)) ->
?Goal1 (?Goal6 (fun A : ?Goal0 => F A))
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : ?Goal0 -> ?Goal0,
?Goal1 (?Goal6 (fun A : ?Goal0 => F A)) ->
forall A : ?Goal0, ?Goal1 (F A)
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
?Goal0
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
?Goal1 ?Goal10 -> Type
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : ?Goal1 ?Goal10,
(?Goal11 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : ?Goal0,
(?Goal1 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
?Goal1 ?Goal10
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
h:?Goal11 ?Goal18
P
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0)
  (f : forall x : ?Goal1 u, ?Goal1 (B x))
  (x : ?Goal1 u),
?Goal4 u (fun x0 : ?Goal1 u => B x0)
  (?Goal3 u B (fun y : ?Goal1 u => f y)) x = 
f x
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (F : ?Goal0 -> ?Goal0)
  (f : forall A : ?Goal0, ?Goal1 (F A)) 
  (A : ?Goal0),
?Goal8 F (?Goal7 F (fun x : ?Goal0 => f x)) A = f A
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
(forall x : ?Goal11 u, ?Goal11 (B x)) ->
?Goal11 (?Goal12 u (fun x : ?Goal11 u => B x))
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
?Goal11 (?Goal12 u B) ->
forall x : ?Goal11 u, ?Goal11 (B x)
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : ?Goal0) (F : ?Goal1 U -> ?Goal1 ?Goal10),
(forall A : ?Goal1 U, ?Goal11 (F A)) ->
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F A))
down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : ?Goal0) (F : ?Goal1 U -> ?Goal1 ?Goal10),
?Goal11 (?Goal15 U (fun A : ?Goal1 U => F A)) ->
forall A : ?Goal1 U, ?Goal11 (F A)

Large universe.

  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Type exact Type1.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Type1 -> Type exact (fun X => X).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : Type1,
((fun X : Type1 => X) u -> Type1) -> Type1 cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : Type1, (u -> Type1) -> Type1 exact (fun u F => forall x, F x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1)
  (B : (fun X : Type1 => X) u -> Type1),
(forall x : (fun X : Type1 => X) u,
 (fun X : Type1 => X) (B x)) ->
(fun X : Type1 => X)
  ((fun (u0 : Type1) (F : u0 -> Type1) =>
    forall x : u0, F x) u
     (fun x : (fun X : Type1 => X) u => B x)) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1) (B : u -> Type1),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1)
  (B : (fun X : Type1 => X) u -> Type1),
(fun X : Type1 => X)
  ((fun (u0 : Type1) (F : u0 -> Type1) =>
    forall x : u0, F x) u B) ->
forall x : (fun X : Type1 => X) u,
(fun X : Type1 => X) (B x) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1) (B : u -> Type1),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
(Type1 -> Type1) -> Type1 exact (fun F => forall A:Prop, F(up A)).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : Type1 -> Type1,
(forall A : Type1, (fun X : Type1 => X) (F A)) ->
(fun X : Type1 => X)
  ((fun F0 : Type1 -> Type1 =>
    forall A : Prop, F0 (up A)) (fun A : Type1 => F A)) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : Type1 -> Type1,
(forall A : Type1, F A) -> forall A : Prop, F (up A) exact (fun F f A => f (up A)).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : Type1 -> Type1,
(fun X : Type1 => X)
  ((fun F0 : Type1 -> Type1 =>
    forall A : Prop, F0 (up A)) (fun A : Type1 => F A)) ->
forall A : Type1, (fun X : Type1 => X) (F A) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall F : Type1 -> Type1,
(forall A : Prop, F (up A)) -> forall A : Type1, F A
    intros F f A.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
f:forall A0 : Prop, F (up A0)
A:Type1
F A
    specialize (f (down A)).down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
A:Type1
f:F (up (down A))
F A
    rewrite up_down in f.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
A:Type1
f:F A
F A
    exact f.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Type1 exact Prop.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
(fun X : Type1 => X) Prop -> Type cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Prop -> Type exact (fun X => X).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : (fun X : Type1 => X) Prop,
((fun X : Prop => X) u -> (fun X : Type1 => X) Prop) ->
(fun X : Type1 => X) Prop cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : Prop, (u -> Prop) -> Prop exact (fun A P => forall x:A, P x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : Type1,
((fun X : Type1 => X) u -> (fun X : Type1 => X) Prop) ->
(fun X : Type1 => X) Prop cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall u : Type1, (u -> Prop) -> Prop exact (fun A P => forall x:A, P x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
(fun X : Type1 => X) Prop cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
Prop exact P.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
h:(fun X : Prop => X) P
P exact h.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1)
  (B : (fun X : Type1 => X) u -> Type1)
  (f : forall x : (fun X : Type1 => X) u,
       (fun X : Type1 => X) (B x))
  (x : (fun X : Type1 => X) u),
(fun (u0 : Type1) (B0 : u0 -> Type1)
   (x0 : forall x0 : u0, B0 x0) => x0) u
  (fun x0 : (fun X : Type1 => X) u => B x0)
  ((fun (u0 : Type1) (B0 : u0 -> Type1)
      (x0 : forall x0 : u0, B0 x0) => x0) u B
     (fun y : (fun X : Type1 => X) u => f y)) x = 
f x cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Type1) (B : u -> Type1)
  (f : forall x : u, B x) (x : u), f x = f x easy.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (F : Type1 -> Type1)
  (f : forall A : Type1, (fun X : Type1 => X) (F A))
  (A : Type1),
(fun (F0 : Type1 -> Type1)
   (f0 : forall A0 : Prop, F0 (up A0)) (A0 : Type1) =>
 let f1 := f0 (down A0) in
 let f2 :=
   eq_rect (up (down A0)) (fun t : Type1 => F0 t) f1
     A0 (up_down A0) in
 f2) F
  ((fun (F0 : Type1 -> Type1)
      (f0 : forall A0 : Type1, F0 A0) (A0 : Prop) =>
    f0 (up A0)) F (fun x : Type1 => f x)) A = f A cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (F : Type1 -> Type1)
  (f : forall A : Type1, F A) (A : Type1),
eq_rect (up (down A)) (fun t : Type1 => F t)
  (f (up (down A))) A (up_down A) = f A
    intros F f A.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
f:forall A0 : Type1, F A0
A:Type1
eq_rect (up (down A)) (fun t : Type1 => F t)
  (f (up (down A))) A (up_down A) = f A
    destruct (up_down A).down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
f:forall A0 : Type1, F A0
A:Type1
eq_rect (up (down A)) (fun t : Type1 => F t)
  (f (up (down A))) (up (down A)) eq_refl =
f (up (down A)) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A0 : Type1, up (down A0) = A0
P:Prop
F:Type1 -> Type1
f:forall A0 : Type1, F A0
A:Type1
f (up (down A)) = f (up (down A))
    reflexivity.
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : (fun X : Type1 => X) Prop)
  (B : (fun X : Prop => X) u ->
       (fun X : Type1 => X) Prop),
(forall x : (fun X : Prop => X) u,
 (fun X : Prop => X) (B x)) ->
(fun X : Prop => X)
  ((fun (A : Prop) (P0 : A -> Prop) =>
    forall x : A, P0 x) u
     (fun x : (fun X : Prop => X) u => B x)) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Prop) (B : u -> Prop),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : (fun X : Type1 => X) Prop)
  (B : (fun X : Prop => X) u ->
       (fun X : Type1 => X) Prop),
(fun X : Prop => X)
  ((fun (A : Prop) (P0 : A -> Prop) =>
    forall x : A, P0 x) u B) ->
forall x : (fun X : Prop => X) u,
(fun X : Prop => X) (B x) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (u : Prop) (B : u -> Prop),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : Type1)
  (F : (fun X : Type1 => X) U ->
       (fun X : Type1 => X) Prop),
(forall A : (fun X : Type1 => X) U,
 (fun X : Prop => X) (F A)) ->
(fun X : Prop => X)
  ((fun (A : Type1) (P0 : A -> Prop) =>
    forall x : A, P0 x) U
     (fun A : (fun X : Type1 => X) U => F A)) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : Type1) (F : U -> Prop),
(forall A : U, F A) -> forall x : U, F x exact (fun _ _ x => x).
  +down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : Type1)
  (F : (fun X : Type1 => X) U ->
       (fun X : Type1 => X) Prop),
(fun X : Prop => X)
  ((fun (A : Type1) (P0 : A -> Prop) =>
    forall x : A, P0 x) U
     (fun A : (fun X : Type1 => X) U => F A)) ->
forall A : (fun X : Type1 => X) U,
(fun X : Prop => X) (F A) cbn.down:Type1 -> Prop
up:Prop -> Type1
up_down:forall A : Type1, up (down A) = A
P:Prop
forall (U : Type1) (F : U -> Prop),
(forall x : U, F x) -> forall A : U, F A exact (fun _ _ x => x).
Qed.

End Paradox.

End NoRetractFromTypeToProp.

A≠Type

No Coq universe can be equal to one of its elements.

Module TypeNeqSmallType.

Unset Universe Polymorphism.

Section Paradox.

Universe U is equal to one of its elements.

Let U := Type.
Variable A:U.
Hypothesis h : U=A.

Universe U is a retract of A

The following context is actually sufficient for the paradox to hold. The hypothesis h:U=A is only used to define down, up and up_down.

Let down (X:U) : A := @eq_rect _ _ (fun X => X) X _ h.
Let up   (X:A) : U := @eq_rect_r _ _ (fun X => X) X _ h.

Lemma up_down : forall (X:U), up (down X) = X.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall X : U, up (down X) = X
Proof.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall X : U, up (down X) = X
  unfold up,down.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall X : U,
eq_rect_r (fun X0 : Type => X0)
  (eq_rect U (fun X0 : Type => X0) X A h) h = X
  rewrite <- h.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall X : U,
eq_rect_r (fun X0 : Type => X0)
  (eq_rect U (fun X0 : Type => X0) X U eq_refl)
  eq_refl = X
  reflexivity.
Qed.

Theorem paradox : False.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
False
Proof.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
False
  Generic.paradox p.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
Type
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
?Goal0 -> Type
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : ?Goal0, (?Goal1 u -> ?Goal0) -> ?Goal0
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
(forall x : ?Goal1 u, ?Goal1 (B x)) ->
?Goal1 (?Goal2 u (fun x : ?Goal1 u => B x))
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0),
?Goal1 (?Goal2 u B) ->
forall x : ?Goal1 u, ?Goal1 (B x)
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
(?Goal0 -> ?Goal0) -> ?Goal0
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : ?Goal0 -> ?Goal0,
(forall A0 : ?Goal0, ?Goal1 (F A0)) ->
?Goal1 (?Goal6 (fun A0 : ?Goal0 => F A0))
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : ?Goal0 -> ?Goal0,
?Goal1 (?Goal6 (fun A0 : ?Goal0 => F A0)) ->
forall A0 : ?Goal0, ?Goal1 (F A0)
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
?Goal0
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
?Goal1 ?Goal10 -> Type
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : ?Goal1 ?Goal10,
(?Goal11 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : ?Goal0,
(?Goal1 u -> ?Goal1 ?Goal10) -> ?Goal1 ?Goal10
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
?Goal1 ?Goal10
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
p:?Goal11 ?Goal18
False
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : ?Goal0) (B : ?Goal1 u -> ?Goal0)
  (f : forall x : ?Goal1 u, ?Goal1 (B x))
  (x : ?Goal1 u),
?Goal4 u (fun x0 : ?Goal1 u => B x0)
  (?Goal3 u B (fun y : ?Goal1 u => f y)) x = 
f x
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (F : ?Goal0 -> ?Goal0)
  (f : forall A0 : ?Goal0, ?Goal1 (F A0))
  (A0 : ?Goal0),
?Goal8 F (?Goal7 F (fun x : ?Goal0 => f x)) A0 = f A0
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
(forall x : ?Goal11 u, ?Goal11 (B x)) ->
?Goal11 (?Goal12 u (fun x : ?Goal11 u => B x))
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : ?Goal1 ?Goal10)
  (B : ?Goal11 u -> ?Goal1 ?Goal10),
?Goal11 (?Goal12 u B) ->
forall x : ?Goal11 u, ?Goal11 (B x)
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : ?Goal0) (F : ?Goal1 U0 -> ?Goal1 ?Goal10),
(forall A0 : ?Goal1 U0, ?Goal11 (F A0)) ->
?Goal11 (?Goal15 U0 (fun A0 : ?Goal1 U0 => F A0))
U:=Type:Type
A:U
h:U = A
down:=fun X : U =>
eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : ?Goal0) (F : ?Goal1 U0 -> ?Goal1 ?Goal10),
?Goal11 (?Goal15 U0 (fun A0 : ?Goal1 U0 => F A0)) ->
forall A0 : ?Goal1 U0, ?Goal11 (F A0)

Large universe

  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
Type exact U.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U -> Type exact (fun X=>X).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : U, ((fun X : U => X) u -> U) -> U cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : U, (u -> U) -> U exact (fun X F => forall x:X, F x).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : (fun X : U => X) u -> U),
(forall x : (fun X : U => X) u, (fun X : U => X) (B x)) ->
(fun X : U => X)
  ((fun (X : U) (F : X -> U) => forall x : X, F x) u
     (fun x : (fun X : U => X) u => B x)) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : u -> U),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : (fun X : U => X) u -> U),
(fun X : U => X)
  ((fun (X : U) (F : X -> U) => forall x : X, F x) u B) ->
forall x : (fun X : U => X) u, (fun X : U => X) (B x) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : u -> U),
(forall x : u, B x) -> forall x : u, B x exact (fun _ _ x => x).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
(U -> U) -> U exact (fun F => forall x:A, F (up x)).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : U -> U,
(forall A0 : U, (fun X : U => X) (F A0)) ->
(fun X : U => X)
  ((fun F0 : U -> U => forall x : A, F0 (up x))
     (fun A0 : U => F A0)) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : U -> U,
(forall A0 : U, F A0) -> forall x : A, F (up x) exact (fun _ f => fun x:A => f (up x)).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : U -> U,
(fun X : U => X)
  ((fun F0 : U -> U => forall x : A, F0 (up x))
     (fun A0 : U => F A0)) ->
forall A0 : U, (fun X : U => X) (F A0) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall F : U -> U,
(forall x : A, F (up x)) -> forall A0 : U, F A0 intros * f X.U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
f:forall x : A, F (up x)
X:U
F X
    specialize (f (down X)).U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
X:U
f:F (up (down X))
F X
    rewrite up_down in f.U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
X:U
f:F X
F X
    exact f.

Small universe

  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U exact A.

The interpretation of A as a universe is U.

  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
(fun X : U => X) A -> Type cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
A -> Type exact up.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : (fun X : U => X) A,
(up u -> (fun X : U => X) A) -> (fun X : U => X) A cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : A, (up u -> A) -> A exact (fun _ F => down (forall x, up (F x))).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : U,
((fun X : U => X) u -> (fun X : U => X) A) ->
(fun X : U => X) A cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall u : U, (u -> A) -> A exact (fun _ F => down (forall x, up (F x))).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
(fun X : U => X) A cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
A exact (down False).
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
p:up (down False)
False rewrite up_down in p.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
p:False
False
    exact p.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : (fun X : U => X) u -> U)
  (f : forall x : (fun X : U => X) u,
       (fun X : U => X) (B x))
  (x : (fun X : U => X) u),
(fun (u0 : U) (B0 : u0 -> U)
   (x0 : forall x0 : u0, B0 x0) => x0) u
  (fun x0 : (fun X : U => X) u => B x0)
  ((fun (u0 : U) (B0 : u0 -> U)
      (x0 : forall x0 : u0, B0 x0) => x0) u B
     (fun y : (fun X : U => X) u => f y)) x = f x cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : U) (B : u -> U) (f : forall x : u, B x)
  (x : u), f x = f x easy.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (F : U -> U)
  (f : forall A0 : U, (fun X : U => X) (F A0))
  (A0 : U),
(fun (F0 : U -> U) (f0 : forall x : A, F0 (up x))
   (X : U) =>
 let f1 := f0 (down X) in
 let f2 :=
   eq_rect (up (down X)) (fun u : U => F0 u) f1 X
     (up_down X) in
 f2) F
  ((fun (F0 : U -> U) (f0 : forall A1 : U, F0 A1)
      (x : A) => f0 (up x)) F (fun x : U => f x)) A0 =
f A0 cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (F : U -> U) (f : forall A0 : U, F A0) (A0 : U),
eq_rect (up (down A0)) (fun u : U => F u)
  (f (up (down A0))) A0 (up_down A0) = f A0 intros ? f X.U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
f:forall A0 : U, F A0
X:U
eq_rect (up (down X)) (fun u : U => F u)
  (f (up (down X))) X (up_down X) = f X
    destruct (up_down X).U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
f:forall A0 : U, F A0
X:U
eq_rect (up (down X)) (fun u : U => F u)
  (f (up (down X))) (up (down X)) eq_refl =
f (up (down X)) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X0 : U => eq_rect U (fun X1 : Type => X1) X0 A h:U -> A
up:=fun X0 : A => eq_rect_r (fun X1 : Type => X1) X0 h:A -> U
F:U -> U
f:forall A0 : U, F A0
X:U
f (up (down X)) = f (up (down X))
    reflexivity.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : (fun X : U => X) A)
  (B : up u -> (fun X : U => X) A),
(forall x : up u, up (B x)) ->
up
  ((fun (u0 : A) (F : up u0 -> A) =>
    down (forall x : up u0, up (F x))) u
     (fun x : up u => B x)) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : A) (B : up u -> A),
(forall x : up u, up (B x)) ->
up (down (forall x : up u, up (B x))) intros ? ? f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
u:A
B:up u -> A
f:forall x : up u, up (B x)
up (down (forall x : up u, up (B x)))
    rewrite up_down.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
u:A
B:up u -> A
f:forall x : up u, up (B x)
forall x : up u, up (B x)
    exact f.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : (fun X : U => X) A)
  (B : up u -> (fun X : U => X) A),
up
  ((fun (u0 : A) (F : up u0 -> A) =>
    down (forall x : up u0, up (F x))) u B) ->
forall x : up u, up (B x) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (u : A) (B : up u -> A),
up (down (forall x : up u, up (B x))) ->
forall x : up u, up (B x) intros ? ? f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
u:A
B:up u -> A
f:up (down (forall x : up u, up (B x)))
forall x : up u, up (B x)
    rewrite up_down in f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
u:A
B:up u -> A
f:forall x : up u, up (B x)
forall x : up u, up (B x)
    exact f.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : U)
  (F : (fun X : U => X) U0 -> (fun X : U => X) A),
(forall A0 : (fun X : U => X) U0, up (F A0)) ->
up
  ((fun (u : U) (F0 : u -> A) =>
    down (forall x : u, up (F0 x))) U0
     (fun A0 : (fun X : U => X) U0 => F A0)) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : U) (F : U0 -> A),
(forall A0 : U0, up (F A0)) ->
up (down (forall x : U0, up (F x))) intros ? ? f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U0:U
F:U0 -> A
f:forall A0 : U0, up (F A0)
up (down (forall x : U0, up (F x)))
    rewrite up_down.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U0:U
F:U0 -> A
f:forall A0 : U0, up (F A0)
forall x : U0, up (F x)
    exact f.
  +U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : U)
  (F : (fun X : U => X) U0 -> (fun X : U => X) A),
up
  ((fun (u : U) (F0 : u -> A) =>
    down (forall x : u, up (F0 x))) U0
     (fun A0 : (fun X : U => X) U0 => F A0)) ->
forall A0 : (fun X : U => X) U0, up (F A0) cbn.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
forall (U0 : U) (F : U0 -> A),
up (down (forall x : U0, up (F x))) ->
forall A0 : U0, up (F A0) intros ? ? f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U0:U
F:U0 -> A
f:up (down (forall x : U0, up (F x)))
forall A0 : U0, up (F A0)
    rewrite up_down in f.U:=Type:Type
A:U
h:U = A
down:=fun X : U => eq_rect U (fun X0 : Type => X0) X A h:U -> A
up:=fun X : A => eq_rect_r (fun X0 : Type => X0) X h:A -> U
U0:U
F:U0 -> A
f:forall x : U0, up (F x)
forall A0 : U0, up (F A0)
    exact f.
Qed.

End Paradox.

End TypeNeqSmallType.

Prop≠Type.

Special case of TypeNeqSmallType.

Module PropNeqType.

Theorem paradox : Prop <> Type.Prop <> Type
Proof.Prop <> Type
  intros h.h:Prop = Type
False
  unshelve (refine (TypeNeqSmallType.paradox _ _)).h:Prop = Type
Type
h:Prop = Type
Type = ?Goal
  +h:Prop = Type
Type exact Prop.
  +h:Prop = Type
Type = Prop easy.
Qed.

End PropNeqType.

(* end show *)