Hartogs.v

From HoTT Require Import TruncType ExcludedMiddle Modalities.ReflectiveSubuniverse abstract_algebra HSet.[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
From HoTT Require Import Universes.Smallness.
From HoTT Require Import Spaces.Card.

From HoTT.Sets Require Import Ordinals Powers.

Close Scope trunc_scope.

(** This file contains a construction of the Hartogs number. *)

(** We begin with some results about changing the universe of a power set using propositional resizing. *)

Definition power_inj `{PropResizing} {C : Type@{i}} (p : C -> HProp@{j})
  : C -> HProp@{k}.H: PropResizing
C: Type
p: C -> HProp
C -> HProp
Proof.H: PropResizing
C: Type
p: C -> HProp
C -> HProp
  exact (fun a => Build_HProp (smalltype@{k j} (p a))).
Defined.

Lemma injective_power_inj `{PropResizing} {ua : Univalence} (C : Type@{i})
  : IsInjective (@power_inj _ C).H: PropResizing
ua: Univalence
C: Type
IsInjective power_inj
Proof.H: PropResizing
ua: Univalence
C: Type
IsInjective power_inj
  intros p p'.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
power_inj p = power_inj p' -> p = p' unfold power_inj.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
(fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a))) ->
p = p' intros q.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
p = p' apply path_forall.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
p == p' intros a.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
p a = p' a apply path_iff_hprop; intros Ha.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
p' a
H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
p a
  -H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
p' a eapply equiv_smalltype.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
smalltype (p' a) change ((fun a => Build_HProp (smalltype (p' a))) a).H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
(fun a : C => Build_HProp (smalltype (p' a))) a
    rewrite <- q.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
Build_HProp (smalltype (p a)) apply equiv_smalltype.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p a
p a exact Ha.
  -H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
p a eapply equiv_smalltype.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
smalltype (p a) change ((fun a => Build_HProp (smalltype (p a))) a).H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
(fun a : C => Build_HProp (smalltype (p a))) a
    rewrite q.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
Build_HProp (smalltype (p' a)) apply equiv_smalltype.H: PropResizing
ua: Univalence
C: Type
p, p': C -> HProp
q: (fun a : C => Build_HProp (smalltype (p a))) =
(fun a : C => Build_HProp (smalltype (p' a)))
a: C
Ha: p' a
p' a exact Ha.
Qed.

(* TODO: Could factor this as something keeping the [HProp] universe the same, followed by [power_inj]. *)
Definition power_morph `{PropResizing} {ua : Univalence} {C B : Type@{i}} (f : C -> B)
  : (C -> HProp) -> (B -> HProp).H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
(C -> HProp) -> B -> HProp
Proof.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
(C -> HProp) -> B -> HProp
  intros p b.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
p: C -> HProp
b: B
HProp exact (Build_HProp (smalltype (forall a, f a = b -> p a))).
Defined.

Definition injective_power_morph `{PropResizing} {ua : Univalence} {C B : Type@{i}} (f : C -> B)
  : IsInjective f -> IsInjective (@power_morph _ _ C B f).H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
IsInjective f -> IsInjective (power_morph f)
Proof.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
IsInjective f -> IsInjective (power_morph f)
  intros Hf p p' q.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
p = p' apply path_forall.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
p == p' intros a.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
p a = p' a apply path_iff_hprop; intros Ha.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
p' a
H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
p a
  -H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
p' a enough (Hp : power_morph f p (f a)).H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
Hp: power_morph f p (f a)
p' a
H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
power_morph f p (f a)
    +H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
Hp: power_morph f p (f a)
p' a rewrite q in Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
Hp: power_morph f p' (f a)
p' a apply equiv_smalltype in Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
Hp: forall a0 : C, f a0 = f a -> p' a0
p' a apply Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
Hp: forall a0 : C, f a0 = f a -> p' a0
f a = f a reflexivity.
    +H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
power_morph f p (f a) apply equiv_smalltype.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
forall a0 : C, f a0 = f a -> p a0 intros a' -> % Hf.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p a
p a exact Ha.
  -H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
p a enough (Hp : power_morph f p' (f a)).H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
Hp: power_morph f p' (f a)
p a
H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
power_morph f p' (f a)
    +H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
Hp: power_morph f p' (f a)
p a rewrite <- q in Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
Hp: power_morph f p (f a)
p a apply equiv_smalltype in Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
Hp: forall a0 : C, f a0 = f a -> p a0
p a apply Hp.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
Hp: forall a0 : C, f a0 = f a -> p a0
f a = f a reflexivity.
    +H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
power_morph f p' (f a) apply equiv_smalltype.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
forall a0 : C, f a0 = f a -> p' a0 intros a' -> % Hf.H: PropResizing
ua: Univalence
C, B: Type
f: C -> B
Hf: IsInjective f
p, p': C -> HProp
q: power_morph f p = power_morph f p'
a: C
Ha: p' a
p' a exact Ha.
Qed.

(** We'll also need this result. *)
Lemma le_Cardinal_lt_Ordinal `{PropResizing} `{Univalence} (B C : Ordinal)
  : B < C -> card B ≤ card C.H: PropResizing
H0: Univalence
B, C: Ordinal
B < C -> card B ≤ card C
Proof.H: PropResizing
H0: Univalence
B, C: Ordinal
B < C -> card B ≤ card C
  intros B_C.H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
card B ≤ card C apply tr.H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
{i : Build_HSet B -> Build_HSet C & IsInjective i} cbn.H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
{i : ordinal_carrier B -> ordinal_carrier C &
IsInjective i} rewrite (bound_property B_C).H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
{i
: ordinal_carrier ↓((H ◁ B) B_C) -> ordinal_carrier C
& IsInjective i}
  exists out.H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
IsInjective out apply isinjective_simulation.H: PropResizing
H0: Univalence
B, C: Ordinal
B_C: B < C
IsSimulation out apply is_simulation_out.
Qed.

(** * Hartogs number *)

Section Hartogs_Number.

  Declare Scope Hartogs.
  Open Scope Hartogs.

  Notation "'𝒫'" := power_type (at level 30) : Hartogs.Identifier '𝒫' now a keyword

  Local Coercion subtype_as_type' {X} (Y : 𝒫 X) := { x : X & Y x }.

  Universe A.
  Context {univalence : Univalence}
          {prop_resizing : PropResizing}
          {lem: ExcludedMiddle}
          (A : HSet@{A}).

  (* The Hartogs number of [A] consists of all ordinals that embed into [A]. Note that this construction necessarily increases the universe level. *)

  Fail Check { B : Ordinal@{A _} | card B <= card A } : Type@{A}.The command has indeed failed with message:
In environment
univalence : Univalence
prop_resizing : PropResizing
lem : ExcludedMiddle
A : HSet
The term "{B : Ordinal & card B ≤ card A}" has type
 "Type@{max(Hartogs.1355,Hartogs.1356)}"
while it is expected to have type "Type@{A}"
(universe inconsistency: Cannot enforce Hartogs.1355
<= A because A < Hartogs.1355).

  Definition hartogs_number' : Ordinal.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
Ordinal
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
Ordinal
    set (carrier := {B : Ordinal@{A _} & card B <= card A}).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
Ordinal
    set (relation := fun (B C : carrier) => B.1 < C.1).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
Ordinal
    exists carrier relation.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsOrdinal carrier lt snapply (isordinal_simulation pr1).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsHSet {B : Ordinal & card B ≤ card A}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
is_mere_relation {B : Ordinal & card B ≤ card A} lt
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
Lt Ordinal
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsOrdinal Ordinal ?Q
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsInjective pr1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsSimulation pr1
    1-4: exact _.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsInjective pr1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsSimulation pr1
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsInjective pr1 apply isinj_embedding, (mapinO_pr1 (Tr (-1))). (* Faster than [exact _.] *)
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
IsSimulation pr1 constructor.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
forall a a' : {B : Ordinal & card B ≤ card A},
a < a' -> a.1 < a'.1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
forall (a : {B : Ordinal & card B ≤ card A})
(b : Ordinal),
b < a.1 ->
hexists
  (fun a' : {B : Ordinal & card B ≤ card A} =>
   ((a' < a) * (a'.1 = b))%type)
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
forall a a' : {B : Ordinal & card B ≤ card A},
a < a' -> a.1 < a'.1 intros a a' a_a'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
a, a': {B : Ordinal & card B ≤ card A}
a_a': a < a'
a.1 < a'.1 exact a_a'.
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal & card B ≤ card A}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
forall (a : {B : Ordinal & card B ≤ card A})
(b : Ordinal),
b < a.1 ->
hexists
  (fun a' : {B : Ordinal & card B ≤ card A} =>
   ((a' < a) * (a'.1 = b))%type) intros [B small_B] C C_B; cbn in *.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
small_B: Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}
C: Ordinal
C_B: C < B
Trunc (-1)
  {a'
  : {B : Ordinal &
    Trunc (-1)
      {i : ordinal_carrier B -> A & IsInjective i}} &
  ((a' < (B; small_B)) * (a'.1 = C))%type} apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
small_B: Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}
C: Ordinal
C_B: C < B
{a'
: {B : Ordinal &
  Trunc (-1)
    {i : ordinal_carrier B -> A & IsInjective i}} &
((a' < (B; small_B)) * (a'.1 = C))%type}
        unshelve eexists (C; _); cbn; auto.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
small_B: Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}
C: Ordinal
C_B: C < B
Trunc (-1)
  {i : ordinal_carrier C -> A & IsInjective i}
        revert small_B.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B, C: Ordinal
C_B: C < B
Trunc (-1)
  {i : ordinal_carrier B -> A & IsInjective i} ->
Trunc (-1)
  {i : ordinal_carrier C -> A & IsInjective i} srapply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B, C: Ordinal
C_B: C < B
{i : ordinal_carrier B -> A & IsInjective i} ->
Trunc (-1)
  {i : ordinal_carrier C -> A & IsInjective i} intros [f isinjective_f].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B, C: Ordinal
C_B: C < B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
Trunc (-1)
  {i : ordinal_carrier C -> A & IsInjective i} apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B, C: Ordinal
C_B: C < B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
{i : ordinal_carrier C -> A & IsInjective i}
        destruct C_B as [b ->].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
b: B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
{i : ordinal_carrier ↓b -> A & IsInjective i}
        exists (fun '(x; x_b) => f x); cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
b: B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
IsInjective
  (fun
     pat : {b0 : ordinal_carrier B &
           smalltype (b0 < b)} => f pat.1)
        intros [x x_b] [y y_b] fx_fy.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
b: B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
x: ordinal_carrier B
x_b: smalltype (x < b)
y: ordinal_carrier B
y_b: smalltype (y < b)
fx_fy: f x = f y
(x; x_b) = (y; y_b) apply path_sigma_hprop; cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
b: B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
x: ordinal_carrier B
x_b: smalltype (x < b)
y: ordinal_carrier B
y_b: smalltype (y < b)
fx_fy: f x = f y
x = y
        apply (isinjective_f x y).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
carrier:= {B : Ordinal &
Trunc (-1)
  {i : ordinal_carrier B -> A &
  IsInjective i}}: Type
relation:= fun B C : carrier => B.1 < C.1: carrier -> carrier -> Type
B: Ordinal
b: B
f: ordinal_carrier B -> A
isinjective_f: IsInjective f
x: ordinal_carrier B
x_b: smalltype (x < b)
y: ordinal_carrier B
y_b: smalltype (y < b)
fx_fy: f x = f y
f x = f y exact fx_fy.
  Defined.

  Definition proper_subtype_inclusion (U V : 𝒫 A)
    := (forall a, U a -> V a) /\ merely (exists a : A, V a /\ ~(U a)).

  Infix "⊊" := proper_subtype_inclusion (at level 50) : Hartogs.
  Notation "(⊊)" := proper_subtype_inclusion : Hartogs.

  (* The Hartogs number of [A] embeds into the threefold power set of [A].  This preliminary injection also increases the universe level though. *)

  Lemma hartogs_number'_injection
    : exists f : hartogs_number' -> (𝒫 (𝒫 (𝒫 A))), IsInjective f.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
{f : hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f}
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
{f : hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f}
    transparent assert (ϕ : (forall X : 𝒫 (𝒫 A), Lt X)).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
forall X : (𝒫) ((𝒫) A), Lt X
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= ?Goal: forall X : (𝒫) ((𝒫) A), Lt X
{f : hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f} {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
forall X : (𝒫) ((𝒫) A), Lt X
      intros X.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) A)
Lt X intros x1 x2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) A)
x1, x2: X
Type exact (x1.1 ⊊ x2.1).
    }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
{f : hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f}
    unshelve eexists.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A))
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
IsInjective ?f
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
hartogs_number' -> (𝒫) ((𝒫) ((𝒫) A)) intros [B _].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B: Ordinal
(𝒫) ((𝒫) ((𝒫) A)) intros X.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B: Ordinal
X: (𝒫) ((𝒫) A)
HProp exact (merely (Isomorphism (X : Type; ϕ X) B)).
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
IsInjective
  (fun X : hartogs_number' =>
   (fun (B : Ordinal) (_ : card B ≤ card A) =>
    (fun X0 : (𝒫) ((𝒫) A) =>
     merely (Isomorphism (X0 : Type; ϕ X0) B))
    :
    (𝒫) ((𝒫) ((𝒫) A))) X.1 X.2) intros [B B_A] [C C_A] H0.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B: Ordinal
B_A: card B ≤ card A
C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
(B; B_A) = (C; C_A) apply path_sigma_hprop; cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B: Ordinal
B_A: card B ≤ card A
C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
B = C
      revert B_A.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
card B ≤ card A -> B = C rapply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
{i : Build_HSet B -> Build_HSet A & IsInjective i} ->
B = C intros [f injective_f].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
B = C
      apply equiv_path_Ordinal.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
Isomorphism B C
      assert {X : 𝒫 (𝒫 A) & Isomorphism (X : Type; ϕ X) B} as [X iso].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
{X : (𝒫) ((𝒫) A) & Isomorphism (X; ϕ X) B}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) ((𝒫) A)
iso: Isomorphism (X; ϕ X) B
Isomorphism B C {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
{X : (𝒫) ((𝒫) A) & Isomorphism (X; ϕ X) B}
        assert (H2 :
                  forall X : 𝒫 A,
                    IsHProp { b : B & forall a, X a <-> exists b', b' < b /\ a = f b' }).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{X : (𝒫) ((𝒫) A) & Isomorphism (X; ϕ X) B} {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
          intros X.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}} apply hprop_allpath; intros [b1 Hb1] [b2 Hb2].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
(b1; Hb1) = (b2; Hb2)
          snapply path_sigma_hprop; cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
forall x : ordinal_carrier B,
IsHProp
  (forall a : A,
   X a <->
   {b' : ordinal_carrier B &
   ((b' < x) * (a = f b'))%type})
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b1 = b2
          -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
forall x : ordinal_carrier B,
IsHProp
  (forall a : A,
   X a <->
   {b' : ordinal_carrier B &
   ((b' < x) * (a = f b'))%type}) intros b.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
IsHProp
  (forall a : A,
   X a <->
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type}) snapply istrunc_forall.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
forall a : A,
IsHProp
  ((fun a0 : A =>
    X a0 <->
    {b' : ordinal_carrier B &
    ((b' < b) * (a0 = f b'))%type}) a)
            intros a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
IsHProp
  ((fun a : A =>
    X a <->
    {b' : ordinal_carrier B &
    ((b' < b) * (a = f b'))%type}) a) snapply istrunc_prod.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
IsHProp
  (X a ->
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type})
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
IsHProp
  ({b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type} -> 
   X a) 2: exact _.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
IsHProp
  (X a ->
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type})
            snapply istrunc_arrow.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
IsHProp
  {b' : ordinal_carrier B &
  ((b' < b) * (a = f b'))%type}
            rapply ishprop_sigma_disjoint.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b: ordinal_carrier B
a: A
forall x y : ordinal_carrier B,
(x < b) * (a = f x) -> (y < b) * (a = f y) -> x = y intros b1' b2' [_ ->] [_ p].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b, b1', b2': ordinal_carrier B
p: f b1' = f b2'
b1' = b2'
            apply (injective_f).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b, b1', b2': ordinal_carrier B
p: f b1' = f b2'
f b1' = f b2' exact p.
          -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b1 = b2 apply extensionality.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
forall c : ordinal_carrier B, c < b1 <-> c < b2 intros b'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b' < b1 <-> b' < b2 split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b' < b1 -> b' < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b' < b2 -> b' < b1
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b' < b1 -> b' < b2 intros b'_b1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b'_b1: b' < b1
b' < b2
              specialize (Hb1 (f b')).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
Hb1: X (f b') <->
{b'0 : B & ((b'0 < b1) * (f b' = f b'0))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2 apply snd in Hb1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
Hb1: {b'0 : B & ((b'0 < b1) * (f b' = f b'0))%type} ->
X (f b')
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2
              specialize (Hb1 (b'; (b'_b1, idpath))).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
Hb1: X (f b')
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2
              apply Hb2 in Hb1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2: B
Hb1: {b'0 : B & ((b'0 < b2) * (f b' = f b'0))%type}
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2 destruct Hb1 as (? & H2 & H3).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2, proj1: B
H2: proj1 < b2
H3: f b' = f proj1
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2
              apply injective in H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2, proj1: B
H2: proj1 < b2
H3: b' = proj1
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2, proj1: B
H2: proj1 < b2
H3: f b' = f proj1
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
IsInjective f 2: assumption.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2, proj1: B
H2: proj1 < b2
H3: b' = proj1
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2 destruct H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
b': ordinal_carrier B
b2: B
H2: b' < b2
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b'_b1: b' < b1
b' < b2
              exact H2.
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b' < b2 -> b' < b1 intros b'_b2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
Hb2: forall a : A,
X a <-> {b' : B & ((b' < b2) * (a = f b'))%type}
b': ordinal_carrier B
b'_b2: b' < b2
b' < b1
              specialize (Hb2 (f b')).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
Hb2: X (f b') <->
{b'0 : B & ((b'0 < b2) * (f b' = f b'0))%type}
b'_b2: b' < b2
b' < b1 apply snd in Hb2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
Hb2: {b'0 : B & ((b'0 < b2) * (f b' = f b'0))%type} ->
X (f b')
b'_b2: b' < b2
b' < b1
              specialize (Hb2 (b'; (b'_b2, idpath))).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
Hb2: X (f b')
b'_b2: b' < b2
b' < b1
              apply Hb1 in Hb2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
Hb2: {b'0 : B & ((b'0 < b1) * (f b' = f b'0))%type}
b'_b2: b' < b2
b' < b1 destruct Hb2 as (? & H2 & H3).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
proj1: B
H2: proj1 < b1
H3: f b' = f proj1
b'_b2: b' < b2
b' < b1
              apply injective in H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
proj1: B
H2: proj1 < b1
H3: b' = proj1
b'_b2: b' < b2
b' < b1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
proj1: B
H2: proj1 < b1
H3: f b' = f proj1
b'_b2: b' < b2
IsInjective f 2: assumption.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
proj1: B
H2: proj1 < b1
H3: b' = proj1
b'_b2: b' < b2
b' < b1 destruct H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) A
b1: B
Hb1: forall a : A,
X a <-> {b' : B & ((b' < b1) * (a = f b'))%type}
b2: B
b': ordinal_carrier B
H2: b' < b1
b'_b2: b' < b2
b' < b1
              exact H2.
        }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{X : (𝒫) ((𝒫) A) & Isomorphism (X; ϕ X) B}
        exists (fun X : 𝒫 A =>
             Build_HProp { b : B & forall a, X a <-> exists b', b' < b /\ a = f b' }).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
Isomorphism
  (fun X : (𝒫) A =>
   Build_HProp
     {b : B &
     forall a : A,
     X a <-> {b' : B & ((b' < b) * (a = f b'))%type}};
  ϕ
    (fun X : (𝒫) A =>
     Build_HProp
       {b : B &
       forall a : A,
       X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}))
  B {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
Isomorphism
  (fun X : (𝒫) A =>
   Build_HProp
     {b : B &
     forall a : A,
     X a <-> {b' : B & ((b' < b) * (a = f b'))%type}};
  ϕ
    (fun X : (𝒫) A =>
     Build_HProp
       {b : B &
       forall a : A,
       X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}))
  B
          unfold subtype_as_type'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
Isomorphism
  ({x : (𝒫) A &
   Build_HProp
     {b : B &
     forall a : A,
     x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}};
  ϕ
    (fun X : (𝒫) A =>
     Build_HProp
       {b : B &
       forall a : A,
       X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}))
  B
          unshelve eexists.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}} <~>
B.1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
forall
(a : {x : (𝒫) A &
     Build_HProp
       {b : B &
       forall a : A,
       x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}})
(a' : {x : (𝒫) A &
      Build_HProp
        {b : B &
        forall a0 : A,
        x a0 <->
        {b' : B & ((b' < b) * (a0 = f b'))%type}}}),
ϕ
  (fun X : (𝒫) A =>
   Build_HProp
     {b : B &
     forall a0 : A,
     X a0 <-> {b' : B & ((b' < b) * (a0 = f b'))%type}})
  a a' <-> B.2 (?f a) (?f a')
          -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}} <~>
B.1 srapply equiv_adjointify.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}} ->
B
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
B ->
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
?f o ?g == idmap
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
?g o ?f == idmap
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}} ->
B intros [X [b _]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X: (𝒫) A
b: B
B exact b.
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
B ->
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}} intros b.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
{x : (𝒫) A &
Build_HProp
  {b : B &
  forall a : A,
  x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}}
              unshelve eexists (fun a => Build_HProp (exists b', b' < b /\ a = f b')).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
b': B
Lt B
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
IsHProp {b' : B & ((b' < b) * (a = f b'))%type}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
Build_HProp
  {b0 : B &
  forall a : A,
  Build_HProp {b' : B & ((b' < b) * (a = f b'))%type} <->
  {b' : B & ((b' < b0) * (a = f b'))%type}}
              1: exact _.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
IsHProp {b' : B & ((b' < b) * (a = f b'))%type}
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
Build_HProp
  {b0 : B &
  forall a : A,
  Build_HProp {b' : B & ((b' < b) * (a = f b'))%type} <->
  {b' : B & ((b' < b0) * (a = f b'))%type}}
              {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
IsHProp {b' : B & ((b' < b) * (a = f b'))%type}
                apply hprop_allpath.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
forall x y : {b' : B & ((b' < b) * (a = f b'))%type},
x = y intros [b1 [b1_b p]] [b2 [b2_b q]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
b1: B
b1_b: b1 < b
p: a = f b1
b2: B
b2_b: b2 < b
q: a = f b2
(b1; (b1_b, p)) = (b2; (b2_b, q))
                apply path_sigma_hprop; cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
b1: B
b1_b: b1 < b
p: a = f b1
b2: B
b2_b: b2 < b
q: a = f b2
b1 = b2 apply (injective f).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
b1: B
b1_b: b1 < b
p: a = f b1
b2: B
b2_b: b2 < b
q: a = f b2
f b1 = f b2
                destruct p, q.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
a: Build_HSet A
b1: B
b1_b: b1 < b
b2: B
b2_b: b2 < b
a = a reflexivity.
              }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
Build_HProp
  {b0 : B &
  forall a : A,
  Build_HProp {b' : B & ((b' < b) * (a = f b'))%type} <->
  {b' : B & ((b' < b0) * (a = f b'))%type}}
              exists b.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
forall a : A,
Build_HProp {b' : B & ((b' < b) * (a = f b'))%type} <->
{b' : B & ((b' < b) * (a = f b'))%type} intros b'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
b': A
Build_HProp
  {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
{b'0 : B & ((b'0 < b) * (b' = f b'0))%type} cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
b: B
b': A
{b'0 : ordinal_carrier B &
((b'0 < b) * (b' = f b'0))%type} <->
{b'0 : ordinal_carrier B &
((b'0 < b) * (b' = f b'0))%type} reflexivity.
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
(fun
   X0 : {x : (𝒫) A &
        Build_HProp
          {b : B &
          forall a : A,
          x a <->
          {b' : B & ((b' < b) * (a = f b'))%type}}} =>
 (fun (X : (𝒫) A)
    (proj2 : Build_HProp
               {b : B &
               forall a : A,
               X a <->
               {b' : B & ((b' < b) * (a = f b'))%type}})
  =>
  (fun (b : B)
     (_ : forall a : A,
          X a <->
          {b' : B & ((b' < b) * (a = f b'))%type}) =>
   b) proj2.1 proj2.2) X0.1 X0.2)
o (fun b : B =>
   (fun a : Build_HSet A =>
    Build_HProp
      {b' : B & ((b' < b) * (a = f b'))%type}; b;
   fun b' : A =>
   iff_reflexive
     {b'0 : ordinal_carrier B &
     ((b'0 < b) * (b' = f b'0))%type}
   :
   Build_HProp
     {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
   {b'0 : B & ((b'0 < b) * (b' = f b'0))%type})) ==
idmap cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
idmap == idmap reflexivity.
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
(fun b : B =>
 (fun a : Build_HSet A =>
  Build_HProp {b' : B & ((b' < b) * (a = f b'))%type};
 b;
 fun b' : A =>
 iff_reflexive
   {b'0 : ordinal_carrier B &
   ((b'0 < b) * (b' = f b'0))%type}
 :
 Build_HProp
   {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
 {b'0 : B & ((b'0 < b) * (b' = f b'0))%type}))
o (fun
     X0 : {x : (𝒫) A &
          Build_HProp
            {b : B &
            forall a : A,
            x a <->
            {b' : B & ((b' < b) * (a = f b'))%type}}}
   =>
   (fun (X : (𝒫) A)
      (proj2 : Build_HProp
                 {b : B &
                 forall a : A,
                 X a <->
                 {b' : B &
                 ((b' < b) * (a = f b'))%type}}) =>
    (fun (b : B)
       (_ : forall a : A,
            X a <->
            {b' : B & ((b' < b) * (a = f b'))%type})
     => b) proj2.1 proj2.2) X0.1 X0.2) == idmap cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
(fun
   x : {x : (𝒫) A &
       {b : ordinal_carrier B &
       forall a : A,
       x a <->
       {b' : ordinal_carrier B &
       ((b' < b) * (a = f b'))%type}}} =>
 (fun a : A =>
  Build_HProp
    {b' : ordinal_carrier B &
    ((b' < (x.2).1) * (a = f b'))%type}; (x.2).1;
 fun b' : A =>
 iff_reflexive
   {b'0 : ordinal_carrier B &
   ((b'0 < (x.2).1) * (b' = f b'0))%type})) == idmap intros [X [b Hb]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X: (𝒫) A
b: ordinal_carrier B
Hb: forall a : A,
X a <->
{b' : ordinal_carrier B &
((b' < b) * (a = f b'))%type}
(fun a : A =>
 Build_HProp
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type}; b;
fun b' : A =>
iff_reflexive
  {b'0 : ordinal_carrier B &
  ((b'0 < b) * (b' = f b'0))%type}) = (X; b; Hb) apply path_sigma_hprop.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X: (𝒫) A
b: ordinal_carrier B
Hb: forall a : A,
X a <->
{b' : ordinal_carrier B &
((b' < b) * (a = f b'))%type}
(fun a : A =>
 Build_HProp
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type}; b;
fun b' : A =>
iff_reflexive
  {b'0 : ordinal_carrier B &
  ((b'0 < b) * (b' = f b'0))%type}).1 = (X; b; Hb).1 cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X: (𝒫) A
b: ordinal_carrier B
Hb: forall a : A,
X a <->
{b' : ordinal_carrier B &
((b' < b) * (a = f b'))%type}
(fun a : A =>
 Build_HProp
   {b' : ordinal_carrier B &
   ((b' < b) * (a = f b'))%type}) = X
              apply path_forall; intros a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X: (𝒫) A
b: ordinal_carrier B
Hb: forall a : A,
X a <->
{b' : ordinal_carrier B &
((b' < b) * (a = f b'))%type}
a: A
Build_HProp
  {b' : ordinal_carrier B &
  ((b' < b) * (a = f b'))%type} = X a apply path_iff_hprop; apply Hb.
          -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
forall
(a : {x : (𝒫) A &
     Build_HProp
       {b : B &
       forall a : A,
       x a <-> {b' : B & ((b' < b) * (a = f b'))%type}}})
(a' : {x : (𝒫) A &
      Build_HProp
        {b : B &
        forall a0 : A,
        x a0 <->
        {b' : B & ((b' < b) * (a0 = f b'))%type}}}),
ϕ
  (fun X : (𝒫) A =>
   Build_HProp
     {b : B &
     forall a0 : A,
     X a0 <-> {b' : B & ((b' < b) * (a0 = f b'))%type}})
  a a' <->
B.2
  (equiv_adjointify
     (fun
        X0 : {x : (𝒫) A &
             Build_HProp
               {b : B &
               forall a0 : A,
               x a0 <->
               {b' : B &
               ((b' < b) * (a0 = f b'))%type}}} =>
      (fun (X : (𝒫) A)
         (proj2 : Build_HProp
                    {b : B &
                    forall a0 : A,
                    X a0 <->
                    {b' : B &
                    ((b' < b) * (a0 = f b'))%type}})
       =>
       (fun (b : B)
          (_ : forall a0 : A,
               X a0 <->
               {b' : B &
               ((b' < b) * (a0 = f b'))%type}) => b)
         proj2.1 proj2.2) X0.1 X0.2)
     (fun b : B =>
      (fun a0 : Build_HSet A =>
       Build_HProp
         {b' : B & ((b' < b) * (a0 = f b'))%type}; b;
      fun b' : A =>
      iff_reflexive
        {b'0 : ordinal_carrier B &
        ((b'0 < b) * (b' = f b'0))%type}
      :
      Build_HProp
        {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
      {b'0 : B & ((b'0 < b) * (b' = f b'0))%type}))
     ((fun x0 : ordinal_carrier B => 1%path)
      :
      (fun
         X0 : {x : (𝒫) A &
              Build_HProp
                {b : B &
                forall a0 : A,
                x a0 <->
                {b' : B &
                ((b' < b) * (a0 = f b'))%type}}} =>
       (fun (X : (𝒫) A)
          (proj2 : Build_HProp
                     {b : B &
                     forall a0 : A,
                     X a0 <->
                     {b' : B &
                     ((b' < b) * (a0 = f b'))%type}})
        =>
        (fun (b : B)
           (_ : forall a0 : A,
                X a0 <->
                {b' : B &
                ((b' < b) * (a0 = f b'))%type}) => b)
          proj2.1 proj2.2) X0.1 X0.2)
      o (fun b : B =>
         (fun a0 : Build_HSet A =>
          Build_HProp
            {b' : B & ((b' < b) * (a0 = f b'))%type};
         b;
         fun b' : A =>
         iff_reflexive
           {b'0 : ordinal_carrier B &
           ((b'0 < b) * (b' = f b'0))%type}
         :
         Build_HProp
           {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
         {b'0 : B & ((b'0 < b) * (b' = f b'0))%type})) ==
      idmap)
     (((fun
          x : {x : (𝒫) A &
              {b : ordinal_carrier B &
              forall a0 : A,
              x a0 <->
              {b' : ordinal_carrier B &
              ((b' < b) * (a0 = f b'))%type}}} =>
        (fun (X : (𝒫) A)
           (proj2 : {b : ordinal_carrier B &
                    forall a0 : A,
                    X a0 <->
                    {b' : ordinal_carrier B &
                    ((b' < b) * (a0 = f b'))%type}})
         =>
         (fun (b : ordinal_carrier B)
            (Hb : forall a0 : A,
                  X a0 <->
                  {b' : ordinal_carrier B &
                  ((b' < b) * (a0 = f b'))%type}) =>
          path_sigma_hprop
            (fun a0 : A =>
             Build_HProp
               {b' : ordinal_carrier B &
               ((b' < b) * (a0 = f b'))%type}; b;
            fun b' : A =>
            iff_reflexive
              {b'0 : ordinal_carrier B &
              ((b'0 < b) * (b' = f b'0))%type})
            (X; b; Hb)
            (path_forall
               (fun a0 : A =>
                Build_HProp
                  {b' : ordinal_carrier B &
                  (... * ...)%type}) X
               ((fun a0 : A =>
                 path_iff_hprop (...) (...))
                :
                (fun ... => Build_HProp ...) == X)
             :
             (fun a0 : A =>
              Build_HProp
                {b' : ordinal_carrier B &
                (... * ...)%type}; b;
             fun b' : A =>
             iff_reflexive
               {b'0 : ordinal_carrier B &
               (... * ...)%type}).1 = (X; b; Hb).1))
           proj2.1 proj2.2) x.1 x.2)
       :
       (fun
          x : {x : (𝒫) A &
              {b : ordinal_carrier B &
              forall a0 : A,
              x a0 <->
              {b' : ordinal_carrier B &
              ((b' < b) * (a0 = f b'))%type}}} =>
        (fun a0 : A =>
         Build_HProp
           {b' : ordinal_carrier B &
           ((b' < (x.2).1) * (a0 = f b'))%type};
        (x.2).1;
        fun b' : A =>
        iff_reflexive
          {b'0 : ordinal_carrier B &
          ((b'0 < (x.2).1) * (b' = f b'0))%type})) ==
       idmap)
      :
      (fun b : B =>
       (fun a0 : Build_HSet A =>
        Build_HProp
          {b' : B & ((b' < b) * (a0 = f b'))%type}; b;
       fun b' : A =>
       iff_reflexive
         {b'0 : ordinal_carrier B &
         ((b'0 < b) * (b' = f b'0))%type}
       :
       Build_HProp
         {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
       {b'0 : B & ((b'0 < b) * (b' = f b'0))%type}))
      o (fun
           X0 : {x : (𝒫) A &
                Build_HProp
                  {b : B &
                  forall a0 : A,
                  x a0 <->
                  {b' : B &
                  ((b' < b) * (a0 = f b'))%type}}} =>
         (fun (X : (𝒫) A)
            (proj2 : Build_HProp
                       {b : B &
                       forall a0 : A,
                       X a0 <->
                       {b' : B &
                       ((b' < b) * (a0 = f b'))%type}})
          =>
          (fun (b : B)
             (_ : forall a0 : A,
                  X a0 <->
                  {b' : B &
                  ((b' < b) * (a0 = f b'))%type}) => b)
            proj2.1 proj2.2) X0.1 X0.2) == idmap) a)
  (equiv_adjointify
     (fun
        X0 : {x : (𝒫) A &
             Build_HProp
               {b : B &
               forall a0 : A,
               x a0 <->
               {b' : B &
               ((b' < b) * (a0 = f b'))%type}}} =>
      (fun (X : (𝒫) A)
         (proj2 : Build_HProp
                    {b : B &
                    forall a0 : A,
                    X a0 <->
                    {b' : B &
                    ((b' < b) * (a0 = f b'))%type}})
       =>
       (fun (b : B)
          (_ : forall a0 : A,
               X a0 <->
               {b' : B &
               ((b' < b) * (a0 = f b'))%type}) => b)
         proj2.1 proj2.2) X0.1 X0.2)
     (fun b : B =>
      (fun a0 : Build_HSet A =>
       Build_HProp
         {b' : B & ((b' < b) * (a0 = f b'))%type}; b;
      fun b' : A =>
      iff_reflexive
        {b'0 : ordinal_carrier B &
        ((b'0 < b) * (b' = f b'0))%type}
      :
      Build_HProp
        {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
      {b'0 : B & ((b'0 < b) * (b' = f b'0))%type}))
     ((fun x0 : ordinal_carrier B => 1%path)
      :
      (fun
         X0 : {x : (𝒫) A &
              Build_HProp
                {b : B &
                forall a0 : A,
                x a0 <->
                {b' : B &
                ((b' < b) * (a0 = f b'))%type}}} =>
       (fun (X : (𝒫) A)
          (proj2 : Build_HProp
                     {b : B &
                     forall a0 : A,
                     X a0 <->
                     {b' : B &
                     ((b' < b) * (a0 = f b'))%type}})
        =>
        (fun (b : B)
           (_ : forall a0 : A,
                X a0 <->
                {b' : B &
                ((b' < b) * (a0 = f b'))%type}) => b)
          proj2.1 proj2.2) X0.1 X0.2)
      o (fun b : B =>
         (fun a0 : Build_HSet A =>
          Build_HProp
            {b' : B & ((b' < b) * (a0 = f b'))%type};
         b;
         fun b' : A =>
         iff_reflexive
           {b'0 : ordinal_carrier B &
           ((b'0 < b) * (b' = f b'0))%type}
         :
         Build_HProp
           {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
         {b'0 : B & ((b'0 < b) * (b' = f b'0))%type})) ==
      idmap)
     (((fun
          x : {x : (𝒫) A &
              {b : ordinal_carrier B &
              forall a0 : A,
              x a0 <->
              {b' : ordinal_carrier B &
              ((b' < b) * (a0 = f b'))%type}}} =>
        (fun (X : (𝒫) A)
           (proj2 : {b : ordinal_carrier B &
                    forall a0 : A,
                    X a0 <->
                    {b' : ordinal_carrier B &
                    ((b' < b) * (a0 = f b'))%type}})
         =>
         (fun (b : ordinal_carrier B)
            (Hb : forall a0 : A,
                  X a0 <->
                  {b' : ordinal_carrier B &
                  ((b' < b) * (a0 = f b'))%type}) =>
          path_sigma_hprop
            (fun a0 : A =>
             Build_HProp
               {b' : ordinal_carrier B &
               ((b' < b) * (a0 = f b'))%type}; b;
            fun b' : A =>
            iff_reflexive
              {b'0 : ordinal_carrier B &
              ((b'0 < b) * (b' = f b'0))%type})
            (X; b; Hb)
            (path_forall
               (fun a0 : A =>
                Build_HProp
                  {b' : ordinal_carrier B &
                  (... * ...)%type}) X
               ((fun a0 : A =>
                 path_iff_hprop (...) (...))
                :
                (fun ... => Build_HProp ...) == X)
             :
             (fun a0 : A =>
              Build_HProp
                {b' : ordinal_carrier B &
                (... * ...)%type}; b;
             fun b' : A =>
             iff_reflexive
               {b'0 : ordinal_carrier B &
               (... * ...)%type}).1 = (X; b; Hb).1))
           proj2.1 proj2.2) x.1 x.2)
       :
       (fun
          x : {x : (𝒫) A &
              {b : ordinal_carrier B &
              forall a0 : A,
              x a0 <->
              {b' : ordinal_carrier B &
              ((b' < b) * (a0 = f b'))%type}}} =>
        (fun a0 : A =>
         Build_HProp
           {b' : ordinal_carrier B &
           ((b' < (x.2).1) * (a0 = f b'))%type};
        (x.2).1;
        fun b' : A =>
        iff_reflexive
          {b'0 : ordinal_carrier B &
          ((b'0 < (x.2).1) * (b' = f b'0))%type})) ==
       idmap)
      :
      (fun b : B =>
       (fun a0 : Build_HSet A =>
        Build_HProp
          {b' : B & ((b' < b) * (a0 = f b'))%type}; b;
       fun b' : A =>
       iff_reflexive
         {b'0 : ordinal_carrier B &
         ((b'0 < b) * (b' = f b'0))%type}
       :
       Build_HProp
         {b'0 : B & ((b'0 < b) * (b' = f b'0))%type} <->
       {b'0 : B & ((b'0 < b) * (b' = f b'0))%type}))
      o (fun
           X0 : {x : (𝒫) A &
                Build_HProp
                  {b : B &
                  forall a0 : A,
                  x a0 <->
                  {b' : B &
                  ((b' < b) * (a0 = f b'))%type}}} =>
         (fun (X : (𝒫) A)
            (proj2 : Build_HProp
                       {b : B &
                       forall a0 : A,
                       X a0 <->
                       {b' : B &
                       ((b' < b) * (a0 = f b'))%type}})
          =>
          (fun (b : B)
             (_ : forall a0 : A,
                  X a0 <->
                  {b' : B &
                  ((b' < b) * (a0 = f b'))%type}) => b)
            proj2.1 proj2.2) X0.1 X0.2) == idmap) a') cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
forall
(a : {x : (𝒫) A &
     {b : ordinal_carrier B &
     forall a : A,
     x a <->
     {b' : ordinal_carrier B &
     ((b' < b) * (a = f b'))%type}}})
(a' : {x : (𝒫) A &
      {b : ordinal_carrier B &
      forall a0 : A,
      x a0 <->
      {b' : ordinal_carrier B &
      ((b' < b) * (a0 = f b'))%type}}}),
ϕ
  (fun X : (𝒫) A =>
   Build_HProp
     {b : ordinal_carrier B &
     forall a0 : A,
     X a0 <->
     {b' : ordinal_carrier B &
     ((b' < b) * (a0 = f b'))%type}}) a a' <->
(a.2).1 < (a'.2).1 intros [X1 [b1 H'1]] [X2 [b2 H'2]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
ϕ
  (fun X : (𝒫) A =>
   Build_HProp
     {b : ordinal_carrier B &
     forall a : A,
     X a <->
     {b' : ordinal_carrier B &
     ((b' < b) * (a = f b'))%type}}) (X1; b1; H'1)
  (X2; b2; H'2) <-> b1 < b2
            unfold ϕ, proper_subtype_inclusion.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
(forall a : A, (X1; b1; H'1).1 a -> (X2; b2; H'2).1 a) *
merely
  {a : A &
  ((X2; b2; H'2).1 a * ~ (X1; b1; H'1).1 a)%type} <->
b1 < b2 cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
(forall a : A, X1 a -> X2 a) *
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} <-> b1 < b2
            split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
(forall a : A, X1 a -> X2 a) *
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} -> b1 < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1 < b2 ->
(forall a : A, X1 a -> X2 a) *
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type}
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
(forall a : A, X1 a -> X2 a) *
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} -> b1 < b2 intros H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1 < b2
              refine (Trunc_rec _ (trichotomy_ordinal b1 b2)).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
(b1 < b2) + hor (b1 = b2) (b2 < b1) -> b1 < b2 intros [b1_b2 | H4].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1_b2: b1 < b2
b1 < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
H4: hor (b1 = b2) (b2 < b1)
b1 < b2
              *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1_b2: b1 < b2
b1 < b2 exact b1_b2.
              *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
H4: hor (b1 = b2) (b2 < b1)
b1 < b2 revert H4.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
hor (b1 = b2) (b2 < b1) -> b1 < b2 rapply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
(b1 = b2) + (b2 < b1) -> b1 < b2 intros [b1_b2 | b2_b1].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1_b2: b1 = b2
b1 < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b2_b1: b2 < b1
b1 < b2
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1_b2: b1 = b2
b1 < b2 apply Empty_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b1_b2: b1 = b2
Empty destruct H3 as [_ H3].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: Trunc (-1) {a : A & (X2 a * ~ X1 a)%type}
b1_b2: b1 = b2
Empty revert H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} -> Empty rapply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
{a : A & (X2 a * ~ X1 a)%type} -> Empty intros [a [X2a not_X1a]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
a: A
X2a: X2 a
not_X1a: ~ X1 a
Empty
                   apply not_X1a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
a: A
X2a: X2 a
not_X1a: ~ X1 a
X1 a apply H'1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
a: A
X2a: X2 a
not_X1a: ~ X1 a
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type} rewrite b1_b2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
a: A
X2a: X2 a
not_X1a: ~ X1 a
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type} apply H'2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 = b2
a: A
X2a: X2 a
not_X1a: ~ X1 a
X2 a exact X2a.
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b2_b1: b2 < b1
b1 < b2 apply Empty_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: ((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type
b2_b1: b2 < b1
Empty destruct H3 as [_ H3].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
H3: Trunc (-1) {a : A & (X2 a * ~ X1 a)%type}
b2_b1: b2 < b1
Empty revert H3.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} -> Empty rapply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
{a : A & (X2 a * ~ X1 a)%type} -> Empty intros [a [X2a not_X1a]].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
X2a: X2 a
not_X1a: ~ X1 a
Empty
                   apply not_X1a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
X2a: X2 a
not_X1a: ~ X1 a
X1 a apply H'1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
X2a: X2 a
not_X1a: ~ X1 a
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
                   apply H'2 in X2a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
X2a: {b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
not_X1a: ~ X1 a
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type} destruct X2a as [b' [b'_b2 a_fb']].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
                   exists b'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
((b' < b1) * (a = f b'))%type split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
b' < b1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
a = f b'
                   ++univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
b' < b1 transitivity b2; assumption.
                   ++univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b2_b1: b2 < b1
a: A
b': ordinal_carrier B
b'_b2: b' < b2
a_fb': a = f b'
not_X1a: ~ X1 a
a = f b' assumption.
            +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1 < b2 ->
(forall a : A, X1 a -> X2 a) *
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} intros b1_b2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
((forall a : A, X1 a -> X2 a) *
 Trunc (-1) {a : A & X2 a * ~ X1 a})%type split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
forall a : A, X1 a -> X2 a
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type}
              *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
forall a : A, X1 a -> X2 a intros a X1a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
X1a: X1 a
X2 a apply H'2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
X1a: X1 a
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type} apply H'1 in X1a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
X1a: {b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type} destruct X1a as [b' [b'_b1 a_fb']].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
                exists b'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
((b' < b2) * (a = f b'))%type split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
b' < b2
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
a = f b'
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
b' < b2 transitivity b1; assumption.
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
a: A
b': ordinal_carrier B
b'_b1: b' < b1
a_fb': a = f b'
a = f b' assumption.
              *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
Trunc (-1) {a : A & (X2 a * ~ X1 a)%type} apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
{a : A & (X2 a * ~ X1 a)%type} exists (f b1).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
(X2 (f b1) * ~ X1 (f b1))%type split.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
X2 (f b1)
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
~ X1 (f b1)
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
X2 (f b1) apply H'2.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
{b' : ordinal_carrier B &
((b' < b2) * (f b1 = f b'))%type} exists b1; auto.
                --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
~ X1 (f b1) intros X1_fb1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
X1_fb1: X1 (f b1)
Empty apply H'1 in X1_fb1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
X1_fb1: {b' : ordinal_carrier B &
((b' < b1) * (f b1 = f b'))%type}
Empty destruct X1_fb1 as [b' [b'_b1 fb1_fb']].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b': ordinal_carrier B
b'_b1: b' < b1
fb1_fb': f b1 = f b'
Empty
                   apply (injective f) in fb1_fb'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b': ordinal_carrier B
b'_b1: b' < b1
fb1_fb': b1 = b'
Empty destruct fb1_fb'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b'_b1: b1 < b1
Empty
                   apply irreflexivity in b'_b1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b'_b1: Empty
Empty
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b'_b1: b1 < b1
Irreflexive lt 2: exact _.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
H2: forall X : (𝒫) A,
IsHProp
  {b : B &
  forall a : A,
  X a <-> {b' : B & ((b' < b) * (a = f b'))%type}}
X1: (𝒫) A
b1: ordinal_carrier B
H'1: forall a : A,
X1 a <->
{b' : ordinal_carrier B &
((b' < b1) * (a = f b'))%type}
X2: (𝒫) A
b2: ordinal_carrier B
H'2: forall a : A,
X2 a <->
{b' : ordinal_carrier B &
((b' < b2) * (a = f b'))%type}
b1_b2: b1 < b2
b'_b1: Empty
Empty assumption.
        }
      }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) ((𝒫) A)
iso: Isomorphism (X; ϕ X) B
Isomorphism B C
      assert (IsOrdinal X (ϕ X)) by exact (isordinal_simulation iso.1).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) ((𝒫) A)
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B C 
      apply apD10 in H0.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) ==
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C))
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
X: (𝒫) ((𝒫) A)
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B C specialize (H0 X).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: (fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) B)) X =
(fun X : (𝒫) ((𝒫) A) =>
 merely (Isomorphism (X; ϕ X) C)) X
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B C cbn in H0.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B C
      refine (transitive_Isomorphism _ (X : Type; ϕ X) _ _ _).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B (X; ϕ X)
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) C {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism B (X; ϕ X)
        apply isomorphism_inverse.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) B assumption.
      }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) C
      enough (merely (Isomorphism (X : Type; ϕ X) C)).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
X1: merely (Isomorphism (X : Type; ϕ X) C)
Isomorphism (X; ϕ X) C
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
merely (Isomorphism (X; ϕ X) C) {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
X1: merely (Isomorphism (X : Type; ϕ X) C)
Isomorphism (X; ϕ X) C
        revert X1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
merely (Isomorphism (X : Type; ϕ X) C) ->
Isomorphism (X; ϕ X) C napply Trunc_rec.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
IsHProp (Isomorphism (X; ϕ X) C)
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) C -> Isomorphism (X; ϕ X) C {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
IsHProp (Isomorphism (X; ϕ X) C)
          exact (ishprop_Isomorphism (Build_Ordinal X (ϕ X) _) C).
        }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) C -> Isomorphism (X; ϕ X) C
        auto.
      }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
merely (Isomorphism (X; ϕ X) C)
      rewrite <- H0.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
merely (Isomorphism (X; ϕ X) B) apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
ϕ:= fun X : (𝒫) ((𝒫) A) =>
(fun x1 x2 : X => (⊊) x1.1 x2.1) : Lt X: forall X : (𝒫) ((𝒫) A), Lt X
B, C: Ordinal
C_A: card C ≤ card A
X: (𝒫) ((𝒫) A)
H0: merely (Isomorphism (X; ϕ X) B) =
merely (Isomorphism (X; ϕ X) C)
f: Build_HSet B -> Build_HSet A
injective_f: IsInjective f
iso: Isomorphism (X; ϕ X) B
X0: IsOrdinal X (ϕ X)
Isomorphism (X; ϕ X) B exact iso.
  Qed.

  (** Using hprop resizing, the threefold power set can be pushed to the same universe level as [A]. *)

  Definition uni_fix (X : 𝒫 (𝒫 (𝒫 A))) : ((𝒫 (𝒫 (𝒫 A))) : Type@{A}).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
(𝒫) ((𝒫) ((𝒫) A)) : Type
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
(𝒫) ((𝒫) ((𝒫) A)) : Type
    revert X.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
(𝒫) ((𝒫) ((𝒫) A)) -> (𝒫) ((𝒫) ((𝒫) A)) : Type
    napply power_morph.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
(𝒫) ((𝒫) A) -> (𝒫) ((𝒫) A)
    napply power_morph.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
(𝒫) A -> (𝒫) A
    exact power_inj.
  Defined.

  Lemma injective_uni_fix : IsInjective uni_fix.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsInjective uni_fix
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsInjective uni_fix
    intros X Y.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
uni_fix X = uni_fix Y -> X = Y unfold uni_fix.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
power_morph (power_morph power_inj) X =
power_morph (power_morph power_inj) Y -> X = Y intros H % injective_power_morph; trivial.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
H: power_morph (power_morph power_inj) X =
power_morph (power_morph power_inj) Y
IsInjective (power_morph power_inj)
    intros P Q.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
H: power_morph (power_morph power_inj) X =
power_morph (power_morph power_inj) Y
P, Q: (𝒫) ((𝒫) A)
power_morph power_inj P = power_morph power_inj Q ->
P = Q intros H' % injective_power_morph; trivial.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
H: power_morph (power_morph power_inj) X =
power_morph (power_morph power_inj) Y
P, Q: (𝒫) ((𝒫) A)
H': power_morph power_inj P = power_morph power_inj Q
IsInjective power_inj
    intros p q.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X, Y: (𝒫) ((𝒫) ((𝒫) A))
H: power_morph (power_morph power_inj) X =
power_morph (power_morph power_inj) Y
P, Q: (𝒫) ((𝒫) A)
H': power_morph power_inj P = power_morph power_inj Q
p, q: (𝒫) A
power_inj p = power_inj q -> p = q apply injective_power_inj.
  Qed.

  (* We can therefore resize the Hartogs number of A to the same universe level as A. *)

  Definition hartogs_number_carrier : Type@{A}
    := {X : 𝒫 (𝒫 (𝒫 A)) | smalltype (merely (exists a, uni_fix (hartogs_number'_injection.1 a) = X))}.

  Lemma hartogs_equiv : hartogs_number_carrier <~> hartogs_number'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
hartogs_number_carrier <~> hartogs_number'
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
hartogs_number_carrier <~> hartogs_number'
    apply equiv_inverse.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
hartogs_number' <~> hartogs_number_carrier unshelve eexists.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
hartogs_number' -> hartogs_number_carrier
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsEquiv ?equiv_fun
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
hartogs_number' -> hartogs_number_carrier intros a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
hartogs_number_carrier exists (uni_fix (hartogs_number'_injection.1 a)).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
      apply equiv_smalltype, tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
{a0 : hartogs_number' &
uni_fix (hartogs_number'_injection.1 a0) =
uni_fix (hartogs_number'_injection.1 a)} exists a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 a) reflexivity.
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsEquiv
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path)))) snapply isequiv_surj_emb.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsConnMap (Tr (-1))
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path))))
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsEmbedding
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation 
           (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path))))
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsConnMap (Tr (-1))
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path)))) apply BuildIsSurjection.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
forall b : hartogs_number_carrier,
merely
  (hfiber
     (fun a : hartogs_number' =>
      (uni_fix (hartogs_number'_injection.1 a);
      let X :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X0 :=
        fun (X0 : Type) (IsSmall : IsSmall X0) =>
        (equiv_smalltype X0)^-1 in
      X0
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (issmall_hprop
           (merely
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)})
           (istrunc_truncation (-1)
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)}))
        (tr (a; 1%path)))) b) intros [X HX].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
merely
  (hfiber
     (fun a : hartogs_number' =>
      (uni_fix (hartogs_number'_injection.1 a);
      let X :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X0 :=
        fun (X0 : Type) (IsSmall : IsSmall X0) =>
        (equiv_smalltype X0)^-1 in
      X0
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (issmall_hprop
           (merely
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)})
           (istrunc_truncation (-1)
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)}))
        (tr (a; 1%path)))) (X; HX)) eapply merely_destruct.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
merely ?A
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
?A ->
merely
  (hfiber
     (fun a : hartogs_number' =>
      (uni_fix (hartogs_number'_injection.1 a);
      let X :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X0 :=
        fun (X0 : Type) (IsSmall : IsSmall X0) =>
        (equiv_smalltype X0)^-1 in
      X0
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (issmall_hprop
           (merely
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)})
           (istrunc_truncation 
              (-1)
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)}))
        (tr (a; 1%path)))) 
     (X; HX))
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
merely ?A eapply equiv_smalltype, HX.
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
{a : hartogs_number' &
uni_fix (hartogs_number'_injection.1 a) = X} ->
merely
  (hfiber
     (fun a : hartogs_number' =>
      (uni_fix (hartogs_number'_injection.1 a);
      let X :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X0 :=
        fun (X0 : Type) (IsSmall : IsSmall X0) =>
        (equiv_smalltype X0)^-1 in
      X0
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (issmall_hprop
           (merely
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)})
           (istrunc_truncation (-1)
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)}))
        (tr (a; 1%path)))) (X; HX)) intros [a <-].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
merely
  (hfiber
     (fun a : hartogs_number' =>
      (uni_fix (hartogs_number'_injection.1 a);
      let X :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X0 :=
        fun (X0 : Type) (IsSmall : IsSmall X0) =>
        (equiv_smalltype X0)^-1 in
      X0
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (issmall_hprop
           (merely
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)})
           (istrunc_truncation (-1)
              {a0 : hartogs_number' &
              uni_fix (hartogs_number'_injection.1 a0) =
              uni_fix (hartogs_number'_injection.1 a)}))
        (tr (a; 1%path))))
     (uni_fix (hartogs_number'_injection.1 a); HX)) cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
Trunc (-1)
  (hfiber
     (fun
        a : {B : Ordinal &
            Trunc (-1)
              {i : ordinal_carrier B -> A &
              IsInjective i}} =>
      (uni_fix (hartogs_number'_injection.1 a);
      (equiv_smalltype
         (Trunc (-1)
            {a0
            : {B : Ordinal &
              Trunc (-1)
                {i : ordinal_carrier B -> A &
                IsInjective i}} &
            uni_fix (hartogs_number'_injection.1 a0) =
            uni_fix (hartogs_number'_injection.1 a)}))^-1
        (tr (a; 1%path))))
     (uni_fix (hartogs_number'_injection.1 a); HX)) apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
hfiber
  (fun
     a : {B : Ordinal &
         Trunc (-1)
           {i : ordinal_carrier B -> A &
           IsInjective i}} =>
   (uni_fix (hartogs_number'_injection.1 a);
   (equiv_smalltype
      (Trunc (-1)
         {a0
         : {B : Ordinal &
           Trunc (-1)
             {i : ordinal_carrier B -> A &
             IsInjective i}} &
         uni_fix (hartogs_number'_injection.1 a0) =
         uni_fix (hartogs_number'_injection.1 a)}))^-1
     (tr (a; 1%path))))
  (uni_fix (hartogs_number'_injection.1 a); HX) exists a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
(uni_fix (hartogs_number'_injection.1 a);
(equiv_smalltype
   (Trunc (-1)
      {a0
      : {B : Ordinal &
        Trunc (-1)
          {i : ordinal_carrier B -> A & IsInjective i}}
      &
      uni_fix (hartogs_number'_injection.1 a0) =
      uni_fix (hartogs_number'_injection.1 a)}))^-1
  (tr (a; 1%path))) =
(uni_fix (hartogs_number'_injection.1 a); HX) cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
(uni_fix (hartogs_number'_injection.1 a);
(equiv_smalltype
   (Trunc (-1)
      {a0
      : {B : Ordinal &
        Trunc (-1)
          {i : ordinal_carrier B -> A & IsInjective i}}
      &
      uni_fix (hartogs_number'_injection.1 a0) =
      uni_fix (hartogs_number'_injection.1 a)}))^-1
  (tr (a; 1%path))) =
(uni_fix (hartogs_number'_injection.1 a); HX) apply ap.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a: hartogs_number'
HX: smalltype
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
(equiv_smalltype
   (Trunc (-1)
      {a0
      : {B : Ordinal &
        Trunc (-1)
          {i : ordinal_carrier B -> A & IsInjective i}}
      &
      uni_fix (hartogs_number'_injection.1 a0) =
      uni_fix (hartogs_number'_injection.1 a)}))^-1
  (tr (a; 1%path)) = HX apply path_ishprop.
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsEmbedding
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path)))) apply isembedding_isinj_hset.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsInjective
  (fun a : hartogs_number' =>
   (uni_fix (hartogs_number'_injection.1 a);
   let X :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X0 :=
     fun (X0 : Type) (IsSmall : IsSmall X0) =>
     (equiv_smalltype X0)^-1 in
   X0
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (issmall_hprop
        (merely
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)})
        (istrunc_truncation (-1)
           {a0 : hartogs_number' &
           uni_fix (hartogs_number'_injection.1 a0) =
           uni_fix (hartogs_number'_injection.1 a)}))
     (tr (a; 1%path)))) intros a b.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
(uni_fix (hartogs_number'_injection.1 a);
let X :=
  fun (X : Type) (IsSmall : IsSmall X) =>
  equiv_isequiv (equiv_smalltype X) in
let X0 :=
  fun (X0 : Type) (IsSmall : IsSmall X0) =>
  (equiv_smalltype X0)^-1 in
X0
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
  (issmall_hprop
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (istrunc_truncation (-1)
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)}))
  (tr (a; 1%path))) =
(uni_fix (hartogs_number'_injection.1 b);
let X :=
  fun (X : Type) (IsSmall : IsSmall X) =>
  equiv_isequiv (equiv_smalltype X) in
let X0 :=
  fun (X0 : Type) (IsSmall : IsSmall X0) =>
  (equiv_smalltype X0)^-1 in
X0
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) =
     uni_fix (hartogs_number'_injection.1 b)})
  (issmall_hprop
     (merely
        {a : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a) =
        uni_fix (hartogs_number'_injection.1 b)})
     (istrunc_truncation (-1)
        {a : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a) =
        uni_fix (hartogs_number'_injection.1 b)}))
  (tr (b; 1%path))) -> a = b intros H % pr1_path.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
H: (uni_fix (hartogs_number'_injection.1 a);
let X :=
  fun (X : Type) (IsSmall : IsSmall X) =>
  equiv_isequiv (equiv_smalltype X) in
let X0 :=
  fun (X0 : Type) (IsSmall : IsSmall X0) =>
  (equiv_smalltype X0)^-1 in
X0
  (merely
     {a0 : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a0) =
     uni_fix (hartogs_number'_injection.1 a)})
  (issmall_hprop
     (merely
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)})
     (istrunc_truncation 
        (-1)
        {a0 : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a0) =
        uni_fix (hartogs_number'_injection.1 a)}))
  (tr (a; 1%path))).1 =
(uni_fix (hartogs_number'_injection.1 b);
let X :=
  fun (X : Type) (IsSmall : IsSmall X) =>
  equiv_isequiv (equiv_smalltype X) in
let X0 :=
  fun (X0 : Type) (IsSmall : IsSmall X0) =>
  (equiv_smalltype X0)^-1 in
X0
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) =
     uni_fix (hartogs_number'_injection.1 b)})
  (issmall_hprop
     (merely
        {a : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a) =
        uni_fix (hartogs_number'_injection.1 b)})
     (istrunc_truncation 
        (-1)
        {a : hartogs_number' &
        uni_fix (hartogs_number'_injection.1 a) =
        uni_fix (hartogs_number'_injection.1 b)}))
  (tr (b; 1%path))).1
a = b cbn in H.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
H: uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 b)
a = b
        specialize (injective_uni_fix (hartogs_number'_injection.1 a) (hartogs_number'_injection.1 b)).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
H: uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 b)
(uni_fix (hartogs_number'_injection.1 a) =
 uni_fix (hartogs_number'_injection.1 b) ->
 hartogs_number'_injection.1 a =
 hartogs_number'_injection.1 b) -> a = b
        intros H'.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
H: uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 b)
H': uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 b) ->
hartogs_number'_injection.1 a =
hartogs_number'_injection.1 b
a = b apply H' in H.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
a, b: hartogs_number'
H: hartogs_number'_injection.1 a =
hartogs_number'_injection.1 b
H': uni_fix (hartogs_number'_injection.1 a) =
uni_fix (hartogs_number'_injection.1 b) ->
hartogs_number'_injection.1 a =
hartogs_number'_injection.1 b
a = b by apply hartogs_number'_injection.2.
  Qed.

  Definition hartogs_number : Ordinal@{A _}
    := resize_ordinal hartogs_number' hartogs_number_carrier hartogs_equiv.

  (* This final definition by satisfies the expected cardinality properties. *)

  Lemma hartogs_number_injection
    : exists f : hartogs_number -> 𝒫 (𝒫 (𝒫 A)), IsInjective f.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
{f : hartogs_number -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f}
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
{f : hartogs_number -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f}  
    cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
{f : hartogs_number_carrier -> (𝒫) ((𝒫) ((𝒫) A)) &
IsInjective f} exists proj1.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
IsInjective pr1 intros [X HX] [Y HY].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
Y: (𝒫) ((𝒫) ((𝒫) A))
HY: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = Y})
(X; HX).1 = (Y; HY).1 -> (X; HX) = (Y; HY) cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
X: (𝒫) ((𝒫) ((𝒫) A))
HX: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = X})
Y: (𝒫) ((𝒫) ((𝒫) A))
HY: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = Y})
X = Y -> (X; HX) = (Y; HY) intros ->.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
Y: (𝒫) ((𝒫) ((𝒫) A))
HX, HY: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = Y})
(Y; HX) = (Y; HY)
    apply ap.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
Y: (𝒫) ((𝒫) ((𝒫) A))
HX, HY: smalltype
  (merely
     {a : hartogs_number' &
     uni_fix (hartogs_number'_injection.1 a) = Y})
HX = HY apply path_ishprop.
  Qed.

  Lemma hartogs_number_no_injection
    : ~ (exists f : hartogs_number -> A, IsInjective f).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
~ {f : hartogs_number -> A & IsInjective f}
  Proof.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
~ {f : hartogs_number -> A & IsInjective f}
    cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
~ {f : hartogs_number_carrier -> A & IsInjective f} intros [f Hf].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
Empty cbn in f.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
Empty
    assert (HN : card hartogs_number <= card A).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
card hartogs_number ≤ card A
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
Empty {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
card hartogs_number ≤ card A apply tr.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
{i : Build_HSet hartogs_number -> Build_HSet A &
IsInjective i} by exists f. }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
Empty
    transparent assert (HNO : hartogs_number').univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
hartogs_number'
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= ?Goal: hartogs_number'
Empty {univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
hartogs_number' exists hartogs_number.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
card hartogs_number ≤ card A exact HN. }univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Empty
    apply (ordinal_initial hartogs_number' HNO).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number' ↓HNO
    eapply (transitive_Isomorphism hartogs_number' hartogs_number).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number' hartogs_number
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number ↓HNO
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number' hartogs_number apply isomorphism_inverse.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number hartogs_number'
      unfold hartogs_number.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism
  (resize_ordinal hartogs_number'
     hartogs_number_carrier hartogs_equiv)
  hartogs_number'
      exact (resize_ordinal_iso hartogs_number' hartogs_number_carrier hartogs_equiv).
    -univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
Isomorphism hartogs_number ↓HNO assert (Isomorphism hartogs_number ↓hartogs_number) by apply isomorphism_to_initial_segment.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
Isomorphism hartogs_number ↓HNO
      eapply transitive_Isomorphism.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
Isomorphism hartogs_number ?B
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
Isomorphism ?B ↓HNO 1: exact X.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
Isomorphism ↓hartogs_number ↓HNO
      unshelve eexists.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
(↓hartogs_number).1 <~> (↓HNO).1
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
forall a a' : (↓hartogs_number).1,
(↓hartogs_number).2 a a' <-> (↓HNO).2 (?f a) (?f a')
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
(↓hartogs_number).1 <~> (↓HNO).1 srapply equiv_adjointify.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
↓hartogs_number -> ↓HNO
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
↓HNO -> ↓hartogs_number
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
?f o ?g == idmap
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
?g o ?f == idmap
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
↓hartogs_number -> ↓HNO intros [a Ha % equiv_smalltype].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
↓HNO unshelve eexists.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
hartogs_number'
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
smalltype (?b < HNO)
          --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
hartogs_number' exists a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
card a ≤ card A transitivity (card hartogs_number).univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
card a ≤ card hartogs_number
univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
card hartogs_number ≤ card A
             ++univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
card a ≤ card hartogs_number napply le_Cardinal_lt_Ordinal; exact Ha.
             ++univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
card hartogs_number ≤ card A exact HN.
          --univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
smalltype
  ((a;
   transitive_card (card a) (card hartogs_number)
     (card A)
     (le_Cardinal_lt_Ordinal a hartogs_number Ha) HN) <
   HNO) apply equiv_smalltype.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
(a;
transitive_card (card a) (card hartogs_number)
  (card A)
  (le_Cardinal_lt_Ordinal a hartogs_number Ha) HN) <
HNO cbn.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: a < hartogs_number
a < hartogs_number exact Ha.
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
↓HNO -> ↓hartogs_number intros [[a Ha] H % equiv_smalltype].univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: card a ≤ card A
H: (a; Ha) < HNO
↓hartogs_number exists a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: card a ≤ card A
H: (a; Ha) < HNO
smalltype (a < hartogs_number)
          apply equiv_smalltype.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: Ordinal
Ha: card a ≤ card A
H: (a; Ha) < HNO
a < hartogs_number exact H.
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
(fun X0 : ↓hartogs_number =>
 (fun (a : Ordinal)
    (Ha : smalltype (a < hartogs_number)) =>
  let X1 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    equiv_fun (equiv_smalltype X) in
  let Ha0 :=
    X1 (a < hartogs_number)
      (issmall_hprop (a < hartogs_number)
         (ordinal_relation_is_mere a hartogs_number))
      Ha in
  ((a;
   transitive_card (card a) (card hartogs_number)
     (card A)
     (le_Cardinal_lt_Ordinal a hartogs_number Ha0) HN);
  let X2 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    equiv_isequiv (equiv_smalltype X) in
  let X3 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    (equiv_smalltype X)^-1 in
  X3
    ((a;
     transitive_card (card a) (card hartogs_number)
       (card A)
       (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
       HN) < HNO)
    (issmall_hprop
       ((a;
        transitive_card (card a) (card hartogs_number)
          (card A)
          (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
          HN) < HNO)
       (ordinal_relation_is_mere
          (a;
          transitive_card (card a)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a hartogs_number
               Ha0) HN) HNO))
    (Ha0
     :
     (a;
     transitive_card (card a) (card hartogs_number)
       (card A)
       (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
       HN) < HNO))) X0.1 X0.2)
o (fun X0 : ↓HNO =>
   (fun proj1 : hartogs_number' =>
    (fun (a : Ordinal) (Ha : card a ≤ card A)
       (H : smalltype ((a; Ha) < HNO)) =>
     let X1 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       equiv_fun (equiv_smalltype X) in
     let H0 :=
       X1 ((a; Ha) < HNO)
         (issmall_hprop ((a; Ha) < HNO)
            (ordinal_relation_is_mere (a; Ha) HNO)) H
       in
     (a;
     let X2 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       equiv_isequiv (equiv_smalltype X) in
     let X3 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       (equiv_smalltype X)^-1 in
     X3 (a < hartogs_number)
       (issmall_hprop (a < hartogs_number)
          (ordinal_relation_is_mere a hartogs_number))
       H0)) proj1.1 proj1.2) X0.1 X0.2) == idmap intro a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: ↓HNO
(let X0 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_fun (equiv_smalltype X) in
 let Ha :=
   X0
     ((let X1 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let H :=
         X1 (((a.1).1; (a.1).2) < HNO)
           (issmall_hprop (((a.1).1; (a.1).2) < HNO)
              (ordinal_relation_is_mere
                 ((a.1).1; (a.1).2) HNO)) a.2 in
       ((a.1).1;
       let X2 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X3 ((a.1).1 < hartogs_number)
         (issmall_hprop ((a.1).1 < hartogs_number)
            (ordinal_relation_is_mere (a.1).1
               hartogs_number)) H)).1 < hartogs_number)
     (issmall_hprop
        ((let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X1 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X3 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1 <
         hartogs_number)
        (ordinal_relation_is_mere
           (let X1 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_fun (equiv_smalltype X) in
            let H :=
              X1 (((a.1).1; (a.1).2) < HNO)
                (issmall_hprop
                   (((a.1).1; (a.1).2) < HNO)
                   (ordinal_relation_is_mere
                      ((a.1).1; (a.1).2) HNO)) a.2 in
            ((a.1).1;
            let X2 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_isequiv (equiv_smalltype X) in
            let X3 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              (equiv_smalltype X)^-1 in
            X3 ((a.1).1 < hartogs_number)
              (issmall_hprop
                 ((a.1).1 < hartogs_number)
                 (ordinal_relation_is_mere (a.1).1
                    hartogs_number)) H)).1
           hartogs_number))
     (let X1 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let H :=
        X1 (((a.1).1; (a.1).2) < HNO)
          (issmall_hprop (((a.1).1; (a.1).2) < HNO)
             (ordinal_relation_is_mere
                ((a.1).1; (a.1).2) HNO)) a.2 in
      ((a.1).1;
      let X2 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X3 ((a.1).1 < hartogs_number)
        (issmall_hprop ((a.1).1 < hartogs_number)
           (ordinal_relation_is_mere (a.1).1
              hartogs_number)) H)).2 in
 (((let X1 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_fun (equiv_smalltype X) in
    let H :=
      X1 (((a.1).1; (a.1).2) < HNO)
        (issmall_hprop (((a.1).1; (a.1).2) < HNO)
           (ordinal_relation_is_mere
              ((a.1).1; (a.1).2) HNO)) a.2 in
    ((a.1).1;
    let X2 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_isequiv (equiv_smalltype X) in
    let X3 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      (equiv_smalltype X)^-1 in
    X3 ((a.1).1 < hartogs_number)
      (issmall_hprop ((a.1).1 < hartogs_number)
         (ordinal_relation_is_mere (a.1).1
            hartogs_number)) H)).1;
  transitive_card
    (card
       (let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H :=
          X1 (((a.1).1; (a.1).2) < HNO)
            (issmall_hprop (((a.1).1; (a.1).2) < HNO)
               (ordinal_relation_is_mere
                  ((a.1).1; (a.1).2) HNO)) a.2 in
        ((a.1).1;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 ((a.1).1 < hartogs_number)
          (issmall_hprop ((a.1).1 < hartogs_number)
             (ordinal_relation_is_mere (a.1).1
                hartogs_number)) H)).1)
    (card hartogs_number) (card A)
    (le_Cardinal_lt_Ordinal
       (let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H :=
          X1 (((a.1).1; (a.1).2) < HNO)
            (issmall_hprop (((a.1).1; (a.1).2) < HNO)
               (ordinal_relation_is_mere
                  ((a.1).1; (a.1).2) HNO)) a.2 in
        ((a.1).1;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 ((a.1).1 < hartogs_number)
          (issmall_hprop ((a.1).1 < hartogs_number)
             (ordinal_relation_is_mere (a.1).1
                hartogs_number)) H)).1 hartogs_number
       Ha) HN);
 let X1 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_isequiv (equiv_smalltype X) in
 let X2 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   (equiv_smalltype X)^-1 in
 X2
   (((let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let H :=
        X3 (((a.1).1; (a.1).2) < HNO)
          (issmall_hprop (((a.1).1; (a.1).2) < HNO)
             (ordinal_relation_is_mere
                ((a.1).1; (a.1).2) HNO)) a.2 in
      ((a.1).1;
      let X4 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X5 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X5 ((a.1).1 < hartogs_number)
        (issmall_hprop ((a.1).1 < hartogs_number)
           (ordinal_relation_is_mere (a.1).1
              hartogs_number)) H)).1;
    transitive_card
      (card
         (let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X3 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X4 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X5 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X5 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1)
      (card hartogs_number) (card A)
      (le_Cardinal_lt_Ordinal
         (let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X3 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X4 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X5 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X5 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1
         hartogs_number Ha) HN) < HNO)
   (issmall_hprop
      (((let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H :=
           X3 (((a.1).1; (a.1).2) < HNO)
             (issmall_hprop (((a.1).1; (a.1).2) < HNO)
                (ordinal_relation_is_mere
                   ((a.1).1; (a.1).2) HNO)) a.2 in
         ((a.1).1;
         let X4 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X5 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X5 ((a.1).1 < hartogs_number)
           (issmall_hprop ((a.1).1 < hartogs_number)
              (ordinal_relation_is_mere (a.1).1
                 hartogs_number)) H)).1;
       transitive_card
         (card
            (let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X3 (((a.1).1; (a.1).2) < HNO)
                 (issmall_hprop
                    (((a.1).1; (a.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a.1).1; (a.1).2) HNO)) a.2 in
             ((a.1).1;
             let X4 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X5 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X5 ((a.1).1 < hartogs_number)
               (issmall_hprop (....1 < hartogs_number)
                  (ordinal_relation_is_mere ....1
                     hartogs_number)) H)).1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal
            (let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X3 (((a.1).1; (a.1).2) < HNO)
                 (issmall_hprop
                    (((a.1).1; (a.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a.1).1; (a.1).2) HNO)) a.2 in
             ((a.1).1;
             let X4 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X5 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X5 ((a.1).1 < hartogs_number)
               (issmall_hprop (....1 < hartogs_number)
                  (ordinal_relation_is_mere ....1
                     hartogs_number)) H)).1
            hartogs_number Ha) HN) < HNO)
      (ordinal_relation_is_mere
         ((let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H :=
             X3 (((a.1).1; (a.1).2) < HNO)
               (issmall_hprop
                  (((a.1).1; (a.1).2) < HNO)
                  (ordinal_relation_is_mere
                     ((a.1).1; (a.1).2) HNO)) a.2 in
           ((a.1).1;
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5 ((a.1).1 < hartogs_number)
             (issmall_hprop ((a.1).1 < hartogs_number)
                (ordinal_relation_is_mere (a.1).1
                   hartogs_number)) H)).1;
         transitive_card
           (card
              (let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (((a.1).1; (a.1).2) < HNO)
                   (issmall_hprop
                      (((a.1).1; (a.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a.1).1; (a.1).2) HNO)) a.2
                 in
               ((a.1).1;
               let X4 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X5 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X5 ((a.1).1 < hartogs_number)
                 (issmall_hprop
                    (....1 < hartogs_number)
                    (ordinal_relation_is_mere ....1
                       hartogs_number)) H)).1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal
              (let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (((a.1).1; (a.1).2) < HNO)
                   (issmall_hprop
                      (((a.1).1; (a.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a.1).1; (a.1).2) HNO)) a.2
                 in
               ((a.1).1;
               let X4 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X5 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X5 ((a.1).1 < hartogs_number)
                 (issmall_hprop
                    (....1 < hartogs_number)
                    (ordinal_relation_is_mere ....1
                       hartogs_number)) H)).1
              hartogs_number Ha) HN) HNO)) Ha)) = a apply path_sigma_hprop.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: ↓HNO
(let X0 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_fun (equiv_smalltype X) in
 let Ha :=
   X0
     ((let X1 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let H :=
         X1 (((a.1).1; (a.1).2) < HNO)
           (issmall_hprop (((a.1).1; (a.1).2) < HNO)
              (ordinal_relation_is_mere
                 ((a.1).1; (a.1).2) HNO)) a.2 in
       ((a.1).1;
       let X2 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X3 ((a.1).1 < hartogs_number)
         (issmall_hprop ((a.1).1 < hartogs_number)
            (ordinal_relation_is_mere (a.1).1
               hartogs_number)) H)).1 < hartogs_number)
     (issmall_hprop
        ((let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X1 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X3 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1 <
         hartogs_number)
        (ordinal_relation_is_mere
           (let X1 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_fun (equiv_smalltype X) in
            let H :=
              X1 (((a.1).1; (a.1).2) < HNO)
                (issmall_hprop
                   (((a.1).1; (a.1).2) < HNO)
                   (ordinal_relation_is_mere
                      ((a.1).1; (a.1).2) HNO)) a.2 in
            ((a.1).1;
            let X2 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_isequiv (equiv_smalltype X) in
            let X3 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              (equiv_smalltype X)^-1 in
            X3 ((a.1).1 < hartogs_number)
              (issmall_hprop
                 ((a.1).1 < hartogs_number)
                 (ordinal_relation_is_mere (a.1).1
                    hartogs_number)) H)).1
           hartogs_number))
     (let X1 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let H :=
        X1 (((a.1).1; (a.1).2) < HNO)
          (issmall_hprop (((a.1).1; (a.1).2) < HNO)
             (ordinal_relation_is_mere
                ((a.1).1; (a.1).2) HNO)) a.2 in
      ((a.1).1;
      let X2 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X3 ((a.1).1 < hartogs_number)
        (issmall_hprop ((a.1).1 < hartogs_number)
           (ordinal_relation_is_mere (a.1).1
              hartogs_number)) H)).2 in
 (((let X1 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_fun (equiv_smalltype X) in
    let H :=
      X1 (((a.1).1; (a.1).2) < HNO)
        (issmall_hprop (((a.1).1; (a.1).2) < HNO)
           (ordinal_relation_is_mere
              ((a.1).1; (a.1).2) HNO)) a.2 in
    ((a.1).1;
    let X2 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_isequiv (equiv_smalltype X) in
    let X3 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      (equiv_smalltype X)^-1 in
    X3 ((a.1).1 < hartogs_number)
      (issmall_hprop ((a.1).1 < hartogs_number)
         (ordinal_relation_is_mere (a.1).1
            hartogs_number)) H)).1;
  transitive_card
    (card
       (let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H :=
          X1 (((a.1).1; (a.1).2) < HNO)
            (issmall_hprop (((a.1).1; (a.1).2) < HNO)
               (ordinal_relation_is_mere
                  ((a.1).1; (a.1).2) HNO)) a.2 in
        ((a.1).1;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 ((a.1).1 < hartogs_number)
          (issmall_hprop ((a.1).1 < hartogs_number)
             (ordinal_relation_is_mere (a.1).1
                hartogs_number)) H)).1)
    (card hartogs_number) (card A)
    (le_Cardinal_lt_Ordinal
       (let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H :=
          X1 (((a.1).1; (a.1).2) < HNO)
            (issmall_hprop (((a.1).1; (a.1).2) < HNO)
               (ordinal_relation_is_mere
                  ((a.1).1; (a.1).2) HNO)) a.2 in
        ((a.1).1;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 ((a.1).1 < hartogs_number)
          (issmall_hprop ((a.1).1 < hartogs_number)
             (ordinal_relation_is_mere (a.1).1
                hartogs_number)) H)).1 hartogs_number
       Ha) HN);
 let X1 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_isequiv (equiv_smalltype X) in
 let X2 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   (equiv_smalltype X)^-1 in
 X2
   (((let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let H :=
        X3 (((a.1).1; (a.1).2) < HNO)
          (issmall_hprop (((a.1).1; (a.1).2) < HNO)
             (ordinal_relation_is_mere
                ((a.1).1; (a.1).2) HNO)) a.2 in
      ((a.1).1;
      let X4 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X5 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X5 ((a.1).1 < hartogs_number)
        (issmall_hprop ((a.1).1 < hartogs_number)
           (ordinal_relation_is_mere (a.1).1
              hartogs_number)) H)).1;
    transitive_card
      (card
         (let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X3 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X4 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X5 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X5 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1)
      (card hartogs_number) (card A)
      (le_Cardinal_lt_Ordinal
         (let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X3 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X4 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X5 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X5 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1
         hartogs_number Ha) HN) < HNO)
   (issmall_hprop
      (((let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H :=
           X3 (((a.1).1; (a.1).2) < HNO)
             (issmall_hprop (((a.1).1; (a.1).2) < HNO)
                (ordinal_relation_is_mere
                   ((a.1).1; (a.1).2) HNO)) a.2 in
         ((a.1).1;
         let X4 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X5 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X5 ((a.1).1 < hartogs_number)
           (issmall_hprop ((a.1).1 < hartogs_number)
              (ordinal_relation_is_mere (a.1).1
                 hartogs_number)) H)).1;
       transitive_card
         (card
            (let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X3 (((a.1).1; (a.1).2) < HNO)
                 (issmall_hprop
                    (((a.1).1; (a.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a.1).1; (a.1).2) HNO)) a.2 in
             ((a.1).1;
             let X4 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X5 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X5 ((a.1).1 < hartogs_number)
               (issmall_hprop (....1 < hartogs_number)
                  (ordinal_relation_is_mere ....1
                     hartogs_number)) H)).1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal
            (let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X3 (((a.1).1; (a.1).2) < HNO)
                 (issmall_hprop
                    (((a.1).1; (a.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a.1).1; (a.1).2) HNO)) a.2 in
             ((a.1).1;
             let X4 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X5 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X5 ((a.1).1 < hartogs_number)
               (issmall_hprop (....1 < hartogs_number)
                  (ordinal_relation_is_mere ....1
                     hartogs_number)) H)).1
            hartogs_number Ha) HN) < HNO)
      (ordinal_relation_is_mere
         ((let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H :=
             X3 (((a.1).1; (a.1).2) < HNO)
               (issmall_hprop
                  (((a.1).1; (a.1).2) < HNO)
                  (ordinal_relation_is_mere
                     ((a.1).1; (a.1).2) HNO)) a.2 in
           ((a.1).1;
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5 ((a.1).1 < hartogs_number)
             (issmall_hprop ((a.1).1 < hartogs_number)
                (ordinal_relation_is_mere (a.1).1
                   hartogs_number)) H)).1;
         transitive_card
           (card
              (let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (((a.1).1; (a.1).2) < HNO)
                   (issmall_hprop
                      (((a.1).1; (a.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a.1).1; (a.1).2) HNO)) a.2
                 in
               ((a.1).1;
               let X4 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X5 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X5 ((a.1).1 < hartogs_number)
                 (issmall_hprop
                    (....1 < hartogs_number)
                    (ordinal_relation_is_mere ....1
                       hartogs_number)) H)).1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal
              (let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (((a.1).1; (a.1).2) < HNO)
                   (issmall_hprop
                      (((a.1).1; (a.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a.1).1; (a.1).2) HNO)) a.2
                 in
               ((a.1).1;
               let X4 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X5 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X5 ((a.1).1 < hartogs_number)
                 (issmall_hprop
                    (....1 < hartogs_number)
                    (ordinal_relation_is_mere ....1
                       hartogs_number)) H)).1
              hartogs_number Ha) HN) HNO)) Ha)).1 =
a.1 apply path_sigma_hprop.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: ↓HNO
((let X0 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    equiv_fun (equiv_smalltype X) in
  let Ha :=
    X0
      ((let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H :=
          X1 (((a.1).1; (a.1).2) < HNO)
            (issmall_hprop (((a.1).1; (a.1).2) < HNO)
               (ordinal_relation_is_mere
                  ((a.1).1; (a.1).2) HNO)) a.2 in
        ((a.1).1;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 ((a.1).1 < hartogs_number)
          (issmall_hprop ((a.1).1 < hartogs_number)
             (ordinal_relation_is_mere (a.1).1
                hartogs_number)) H)).1 <
       hartogs_number)
      (issmall_hprop
         ((let X1 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H :=
             X1 (((a.1).1; (a.1).2) < HNO)
               (issmall_hprop
                  (((a.1).1; (a.1).2) < HNO)
                  (ordinal_relation_is_mere
                     ((a.1).1; (a.1).2) HNO)) a.2 in
           ((a.1).1;
           let X2 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X3 ((a.1).1 < hartogs_number)
             (issmall_hprop ((a.1).1 < hartogs_number)
                (ordinal_relation_is_mere (a.1).1
                   hartogs_number)) H)).1 <
          hartogs_number)
         (ordinal_relation_is_mere
            (let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X1 (((a.1).1; (a.1).2) < HNO)
                 (issmall_hprop
                    (((a.1).1; (a.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a.1).1; (a.1).2) HNO)) a.2 in
             ((a.1).1;
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3 ((a.1).1 < hartogs_number)
               (issmall_hprop
                  ((a.1).1 < hartogs_number)
                  (ordinal_relation_is_mere (a.1).1
                     hartogs_number)) H)).1
            hartogs_number))
      (let X1 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let H :=
         X1 (((a.1).1; (a.1).2) < HNO)
           (issmall_hprop (((a.1).1; (a.1).2) < HNO)
              (ordinal_relation_is_mere
                 ((a.1).1; (a.1).2) HNO)) a.2 in
       ((a.1).1;
       let X2 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X3 ((a.1).1 < hartogs_number)
         (issmall_hprop ((a.1).1 < hartogs_number)
            (ordinal_relation_is_mere (a.1).1
               hartogs_number)) H)).2 in
  (((let X1 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       equiv_fun (equiv_smalltype X) in
     let H :=
       X1 (((a.1).1; (a.1).2) < HNO)
         (issmall_hprop (((a.1).1; (a.1).2) < HNO)
            (ordinal_relation_is_mere
               ((a.1).1; (a.1).2) HNO)) a.2 in
     ((a.1).1;
     let X2 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       equiv_isequiv (equiv_smalltype X) in
     let X3 :=
       fun (X : Type) (IsSmall : IsSmall X) =>
       (equiv_smalltype X)^-1 in
     X3 ((a.1).1 < hartogs_number)
       (issmall_hprop ((a.1).1 < hartogs_number)
          (ordinal_relation_is_mere (a.1).1
             hartogs_number)) H)).1;
   transitive_card
     (card
        (let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H :=
           X1 (((a.1).1; (a.1).2) < HNO)
             (issmall_hprop (((a.1).1; (a.1).2) < HNO)
                (ordinal_relation_is_mere
                   ((a.1).1; (a.1).2) HNO)) a.2 in
         ((a.1).1;
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3 ((a.1).1 < hartogs_number)
           (issmall_hprop ((a.1).1 < hartogs_number)
              (ordinal_relation_is_mere (a.1).1
                 hartogs_number)) H)).1)
     (card hartogs_number) (card A)
     (le_Cardinal_lt_Ordinal
        (let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H :=
           X1 (((a.1).1; (a.1).2) < HNO)
             (issmall_hprop (((a.1).1; (a.1).2) < HNO)
                (ordinal_relation_is_mere
                   ((a.1).1; (a.1).2) HNO)) a.2 in
         ((a.1).1;
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3 ((a.1).1 < hartogs_number)
           (issmall_hprop ((a.1).1 < hartogs_number)
              (ordinal_relation_is_mere (a.1).1
                 hartogs_number)) H)).1 hartogs_number
        Ha) HN);
  let X1 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    equiv_isequiv (equiv_smalltype X) in
  let X2 :=
    fun (X : Type) (IsSmall : IsSmall X) =>
    (equiv_smalltype X)^-1 in
  X2
    (((let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let H :=
         X3 (((a.1).1; (a.1).2) < HNO)
           (issmall_hprop (((a.1).1; (a.1).2) < HNO)
              (ordinal_relation_is_mere
                 ((a.1).1; (a.1).2) HNO)) a.2 in
       ((a.1).1;
       let X4 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X5 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X5 ((a.1).1 < hartogs_number)
         (issmall_hprop ((a.1).1 < hartogs_number)
            (ordinal_relation_is_mere (a.1).1
               hartogs_number)) H)).1;
     transitive_card
       (card
          (let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H :=
             X3 (((a.1).1; (a.1).2) < HNO)
               (issmall_hprop
                  (((a.1).1; (a.1).2) < HNO)
                  (ordinal_relation_is_mere
                     ((a.1).1; (a.1).2) HNO)) a.2 in
           ((a.1).1;
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5 ((a.1).1 < hartogs_number)
             (issmall_hprop ((a.1).1 < hartogs_number)
                (ordinal_relation_is_mere (a.1).1
                   hartogs_number)) H)).1)
       (card hartogs_number) (card A)
       (le_Cardinal_lt_Ordinal
          (let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H :=
             X3 (((a.1).1; (a.1).2) < HNO)
               (issmall_hprop
                  (((a.1).1; (a.1).2) < HNO)
                  (ordinal_relation_is_mere
                     ((a.1).1; (a.1).2) HNO)) a.2 in
           ((a.1).1;
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5 ((a.1).1 < hartogs_number)
             (issmall_hprop ((a.1).1 < hartogs_number)
                (ordinal_relation_is_mere (a.1).1
                   hartogs_number)) H)).1
          hartogs_number Ha) HN) < HNO)
    (issmall_hprop
       (((let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X3 (((a.1).1; (a.1).2) < HNO)
              (issmall_hprop
                 (((a.1).1; (a.1).2) < HNO)
                 (ordinal_relation_is_mere
                    ((a.1).1; (a.1).2) HNO)) a.2 in
          ((a.1).1;
          let X4 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X5 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X5 ((a.1).1 < hartogs_number)
            (issmall_hprop ((a.1).1 < hartogs_number)
               (ordinal_relation_is_mere (a.1).1
                  hartogs_number)) H)).1;
        transitive_card
          (card
             (let X3 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_fun (equiv_smalltype X) in
              let H :=
                X3 (((a.1).1; (a.1).2) < HNO)
                  (issmall_hprop
                     ((....1; ....2) < HNO)
                     (ordinal_relation_is_mere
                        (....1; ....2) HNO)) a.2 in
              ((a.1).1;
              let X4 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_isequiv (equiv_smalltype X)
                in
              let X5 :=
                fun (X : Type) (IsSmall : ...) =>
                (equiv_smalltype X)^-1 in
              X5 ((a.1).1 < hartogs_number)
                (issmall_hprop (...) (...)) H)).1)
          (card hartogs_number) (card A)
          (le_Cardinal_lt_Ordinal
             (let X3 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_fun (equiv_smalltype X) in
              let H :=
                X3 (((a.1).1; (a.1).2) < HNO)
                  (issmall_hprop
                     ((....1; ....2) < HNO)
                     (ordinal_relation_is_mere
                        (....1; ....2) HNO)) a.2 in
              ((a.1).1;
              let X4 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_isequiv (equiv_smalltype X)
                in
              let X5 :=
                fun (X : Type) (IsSmall : ...) =>
                (equiv_smalltype X)^-1 in
              X5 ((a.1).1 < hartogs_number)
                (issmall_hprop (...) (...)) H)).1
             hartogs_number Ha) HN) < HNO)
       (ordinal_relation_is_mere
          ((let X3 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_fun (equiv_smalltype X) in
            let H :=
              X3 (((a.1).1; (a.1).2) < HNO)
                (issmall_hprop
                   (((a.1).1; (a.1).2) < HNO)
                   (ordinal_relation_is_mere
                      ((a.1).1; (a.1).2) HNO)) a.2 in
            ((a.1).1;
            let X4 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_isequiv (equiv_smalltype X) in
            let X5 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              (equiv_smalltype X)^-1 in
            X5 ((a.1).1 < hartogs_number)
              (issmall_hprop
                 ((a.1).1 < hartogs_number)
                 (ordinal_relation_is_mere (a.1).1
                    hartogs_number)) H)).1;
          transitive_card
            (card
               (let X3 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X3 (((a.1).1; (a.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a.2 in
                ((a.1).1;
                let X4 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X5 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X5 ((a.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal
               (let X3 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X3 (((a.1).1; (a.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a.2 in
                ((a.1).1;
                let X4 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X5 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X5 ((a.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1
               hartogs_number Ha) HN) HNO)) Ha)).1).1 =
(a.1).1 reflexivity.
        *univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
(fun X0 : ↓HNO =>
 (fun proj1 : hartogs_number' =>
  (fun (a : Ordinal) (Ha : card a ≤ card A)
     (H : smalltype ((a; Ha) < HNO)) =>
   let X1 :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_fun (equiv_smalltype X) in
   let H0 :=
     X1 ((a; Ha) < HNO)
       (issmall_hprop ((a; Ha) < HNO)
          (ordinal_relation_is_mere (a; Ha) HNO)) H in
   (a;
   let X2 :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     equiv_isequiv (equiv_smalltype X) in
   let X3 :=
     fun (X : Type) (IsSmall : IsSmall X) =>
     (equiv_smalltype X)^-1 in
   X3 (a < hartogs_number)
     (issmall_hprop (a < hartogs_number)
        (ordinal_relation_is_mere a hartogs_number))
     H0)) proj1.1 proj1.2) X0.1 X0.2)
o (fun X0 : ↓hartogs_number =>
   (fun (a : Ordinal)
      (Ha : smalltype (a < hartogs_number)) =>
    let X1 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_fun (equiv_smalltype X) in
    let Ha0 :=
      X1 (a < hartogs_number)
        (issmall_hprop (a < hartogs_number)
           (ordinal_relation_is_mere a hartogs_number))
        Ha in
    ((a;
     transitive_card (card a) (card hartogs_number)
       (card A)
       (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
       HN);
    let X2 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_isequiv (equiv_smalltype X) in
    let X3 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      (equiv_smalltype X)^-1 in
    X3
      ((a;
       transitive_card (card a) (card hartogs_number)
         (card A)
         (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
         HN) < HNO)
      (issmall_hprop
         ((a;
          transitive_card (card a)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a hartogs_number
               Ha0) HN) < HNO)
         (ordinal_relation_is_mere
            (a;
            transitive_card (card a)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a hartogs_number
                 Ha0) HN) HNO))
      (Ha0
       :
       (a;
       transitive_card (card a) (card hartogs_number)
         (card A)
         (le_Cardinal_lt_Ordinal a hartogs_number Ha0)
         HN) < HNO))) X0.1 X0.2) == idmap intro a.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: ↓hartogs_number
(let X0 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_fun (equiv_smalltype X) in
 let H :=
   X0
     ((((let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let Ha :=
           X1 (a.1 < hartogs_number)
             (issmall_hprop (a.1 < hartogs_number)
                (ordinal_relation_is_mere a.1
                   hartogs_number)) a.2 in
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN);
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (issmall_hprop
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN) < HNO)
              (ordinal_relation_is_mere
                 (a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) HNO)) Ha)).1).1;
      ((let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let Ha :=
          X1 (a.1 < hartogs_number)
            (issmall_hprop (a.1 < hartogs_number)
               (ordinal_relation_is_mere a.1
                  hartogs_number)) a.2 in
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN);
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3
          ((a.1;
           transitive_card (card a.1)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a.1
                hartogs_number Ha) HN) < HNO)
          (issmall_hprop
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (ordinal_relation_is_mere
                (a.1;
                transitive_card (card a.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a.1
                     hartogs_number Ha) HN) HNO)) Ha)).1).2) <
      HNO)
     (issmall_hprop
        ((((let X1 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_fun (equiv_smalltype X) in
            let Ha :=
              X1 (a.1 < hartogs_number)
                (issmall_hprop (a.1 < hartogs_number)
                   (ordinal_relation_is_mere a.1
                      hartogs_number)) a.2 in
            ((a.1;
             transitive_card (card a.1)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a.1
                  hartogs_number Ha) HN);
            let X2 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_isequiv (equiv_smalltype X) in
            let X3 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              (equiv_smalltype X)^-1 in
            X3
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN) < HNO)
              (issmall_hprop
                 ((a.1;
                  transitive_card (card a.1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal a.1
                       hartogs_number Ha) HN) < HNO)
                 (ordinal_relation_is_mere
                    (a.1;
                    transitive_card (card a.1)
                      (card hartogs_number) (card A)
                      (le_Cardinal_lt_Ordinal a.1
                         hartogs_number Ha) HN) HNO))
              Ha)).1).1;
         ((let X1 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let Ha :=
             X1 (a.1 < hartogs_number)
               (issmall_hprop (a.1 < hartogs_number)
                  (ordinal_relation_is_mere a.1
                     hartogs_number)) a.2 in
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN);
           let X2 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X3
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (issmall_hprop
                ((a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) < HNO)
                (ordinal_relation_is_mere
                   (a.1;
                   transitive_card (card a.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a.1
                        hartogs_number Ha) HN) HNO))
             Ha)).1).2) < HNO)
        (ordinal_relation_is_mere
           (((let X1 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_fun (equiv_smalltype X) in
              let Ha :=
                X1 (a.1 < hartogs_number)
                  (issmall_hprop
                     (a.1 < hartogs_number)
                     (ordinal_relation_is_mere a.1
                        hartogs_number)) a.2 in
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN);
              let X2 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_isequiv (equiv_smalltype X)
                in
              let X3 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => (equiv_smalltype X)^-1 in
              X3
                ((a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) < HNO)
                (issmall_hprop
                   ((a.1;
                    transitive_card (card a.1)
                      (card hartogs_number) (card A)
                      (le_Cardinal_lt_Ordinal a.1
                         hartogs_number Ha) HN) < HNO)
                   (ordinal_relation_is_mere
                      (a.1;
                      transitive_card (card a.1)
                        (card hartogs_number) (card A)
                        (le_Cardinal_lt_Ordinal a.1
                           hartogs_number Ha) HN) HNO))
                Ha)).1).1;
           ((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X1 (a.1 < hartogs_number)
                 (issmall_hprop (a.1 < hartogs_number)
                    (ordinal_relation_is_mere a.1
                       hartogs_number)) a.2 in
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN);
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3
               ((a.1;
                transitive_card (card a.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a.1
                     hartogs_number Ha) HN) < HNO)
               (issmall_hprop
                  ((a.1;
                   transitive_card (card a.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a.1
                        hartogs_number Ha) HN) < HNO)
                  (ordinal_relation_is_mere
                     (a.1;
                     transitive_card (card a.1)
                       (card hartogs_number) (card A)
                       (le_Cardinal_lt_Ordinal a.1
                          hartogs_number Ha) HN) HNO))
               Ha)).1).2) HNO))
     (let X1 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let Ha :=
        X1 (a.1 < hartogs_number)
          (issmall_hprop (a.1 < hartogs_number)
             (ordinal_relation_is_mere a.1
                hartogs_number)) a.2 in
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN);
      let X2 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X3
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN) < HNO)
        (issmall_hprop
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (ordinal_relation_is_mere
              (a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) HNO)) Ha)).2
   in
 (((let X1 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_fun (equiv_smalltype X) in
    let Ha :=
      X1 (a.1 < hartogs_number)
        (issmall_hprop (a.1 < hartogs_number)
           (ordinal_relation_is_mere a.1
              hartogs_number)) a.2 in
    ((a.1;
     transitive_card (card a.1) (card hartogs_number)
       (card A)
       (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
       HN);
    let X2 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_isequiv (equiv_smalltype X) in
    let X3 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      (equiv_smalltype X)^-1 in
    X3
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN) < HNO)
      (issmall_hprop
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN) < HNO)
         (ordinal_relation_is_mere
            (a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) HNO)) Ha)).1).1;
 let X1 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_isequiv (equiv_smalltype X) in
 let X2 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   (equiv_smalltype X)^-1 in
 X2
   (((let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let Ha :=
        X3 (a.1 < hartogs_number)
          (issmall_hprop (a.1 < hartogs_number)
             (ordinal_relation_is_mere a.1
                hartogs_number)) a.2 in
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN);
      let X4 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X5 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X5
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN) < HNO)
        (issmall_hprop
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (ordinal_relation_is_mere
              (a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) HNO)) Ha)).1).1 <
    hartogs_number)
   (issmall_hprop
      (((let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let Ha :=
           X3 (a.1 < hartogs_number)
             (issmall_hprop (a.1 < hartogs_number)
                (ordinal_relation_is_mere a.1
                   hartogs_number)) a.2 in
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN);
         let X4 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X5 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X5
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (issmall_hprop
              ((a.1;
               transitive_card (...) (...) (...) (...)
                 HN) < HNO)
              (ordinal_relation_is_mere
                 (a.1;
                 transitive_card (...) (...) (...)
                   (...) HN) HNO)) Ha)).1).1 <
       hartogs_number)
      (ordinal_relation_is_mere
         ((let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let Ha :=
             X3 (a.1 < hartogs_number)
               (issmall_hprop (a.1 < hartogs_number)
                  (ordinal_relation_is_mere a.1
                     hartogs_number)) a.2 in
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN);
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (issmall_hprop
                ((a.1;
                 transitive_card (...) (...) (...)
                   (...) HN) < HNO)
                (ordinal_relation_is_mere
                   (a.1;
                   transitive_card (...) (...) (...)
                     (...) HN) HNO)) Ha)).1).1
         hartogs_number)) H)) = a apply path_sigma_hprop.univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
a: ↓hartogs_number
(let X0 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_fun (equiv_smalltype X) in
 let H :=
   X0
     ((((let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let Ha :=
           X1 (a.1 < hartogs_number)
             (issmall_hprop (a.1 < hartogs_number)
                (ordinal_relation_is_mere a.1
                   hartogs_number)) a.2 in
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN);
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (issmall_hprop
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN) < HNO)
              (ordinal_relation_is_mere
                 (a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) HNO)) Ha)).1).1;
      ((let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let Ha :=
          X1 (a.1 < hartogs_number)
            (issmall_hprop (a.1 < hartogs_number)
               (ordinal_relation_is_mere a.1
                  hartogs_number)) a.2 in
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN);
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3
          ((a.1;
           transitive_card (card a.1)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a.1
                hartogs_number Ha) HN) < HNO)
          (issmall_hprop
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (ordinal_relation_is_mere
                (a.1;
                transitive_card (card a.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a.1
                     hartogs_number Ha) HN) HNO)) Ha)).1).2) <
      HNO)
     (issmall_hprop
        ((((let X1 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_fun (equiv_smalltype X) in
            let Ha :=
              X1 (a.1 < hartogs_number)
                (issmall_hprop (a.1 < hartogs_number)
                   (ordinal_relation_is_mere a.1
                      hartogs_number)) a.2 in
            ((a.1;
             transitive_card (card a.1)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a.1
                  hartogs_number Ha) HN);
            let X2 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              equiv_isequiv (equiv_smalltype X) in
            let X3 :=
              fun (X : Type) (IsSmall : IsSmall X) =>
              (equiv_smalltype X)^-1 in
            X3
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN) < HNO)
              (issmall_hprop
                 ((a.1;
                  transitive_card (card a.1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal a.1
                       hartogs_number Ha) HN) < HNO)
                 (ordinal_relation_is_mere
                    (a.1;
                    transitive_card (card a.1)
                      (card hartogs_number) (card A)
                      (le_Cardinal_lt_Ordinal a.1
                         hartogs_number Ha) HN) HNO))
              Ha)).1).1;
         ((let X1 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let Ha :=
             X1 (a.1 < hartogs_number)
               (issmall_hprop (a.1 < hartogs_number)
                  (ordinal_relation_is_mere a.1
                     hartogs_number)) a.2 in
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN);
           let X2 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X3
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (issmall_hprop
                ((a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) < HNO)
                (ordinal_relation_is_mere
                   (a.1;
                   transitive_card (card a.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a.1
                        hartogs_number Ha) HN) HNO))
             Ha)).1).2) < HNO)
        (ordinal_relation_is_mere
           (((let X1 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_fun (equiv_smalltype X) in
              let Ha :=
                X1 (a.1 < hartogs_number)
                  (issmall_hprop
                     (a.1 < hartogs_number)
                     (ordinal_relation_is_mere a.1
                        hartogs_number)) a.2 in
              ((a.1;
               transitive_card (card a.1)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a.1
                    hartogs_number Ha) HN);
              let X2 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => equiv_isequiv (equiv_smalltype X)
                in
              let X3 :=
                fun (X : Type) (IsSmall : IsSmall X)
                => (equiv_smalltype X)^-1 in
              X3
                ((a.1;
                 transitive_card (card a.1)
                   (card hartogs_number) (card A)
                   (le_Cardinal_lt_Ordinal a.1
                      hartogs_number Ha) HN) < HNO)
                (issmall_hprop
                   ((a.1;
                    transitive_card (card a.1)
                      (card hartogs_number) (card A)
                      (le_Cardinal_lt_Ordinal a.1
                         hartogs_number Ha) HN) < HNO)
                   (ordinal_relation_is_mere
                      (a.1;
                      transitive_card (card a.1)
                        (card hartogs_number) (card A)
                        (le_Cardinal_lt_Ordinal a.1
                           hartogs_number Ha) HN) HNO))
                Ha)).1).1;
           ((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X1 (a.1 < hartogs_number)
                 (issmall_hprop (a.1 < hartogs_number)
                    (ordinal_relation_is_mere a.1
                       hartogs_number)) a.2 in
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN);
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3
               ((a.1;
                transitive_card (card a.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a.1
                     hartogs_number Ha) HN) < HNO)
               (issmall_hprop
                  ((a.1;
                   transitive_card (card a.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a.1
                        hartogs_number Ha) HN) < HNO)
                  (ordinal_relation_is_mere
                     (a.1;
                     transitive_card (card a.1)
                       (card hartogs_number) (card A)
                       (le_Cardinal_lt_Ordinal a.1
                          hartogs_number Ha) HN) HNO))
               Ha)).1).2) HNO))
     (let X1 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let Ha :=
        X1 (a.1 < hartogs_number)
          (issmall_hprop (a.1 < hartogs_number)
             (ordinal_relation_is_mere a.1
                hartogs_number)) a.2 in
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN);
      let X2 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X3
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN) < HNO)
        (issmall_hprop
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (ordinal_relation_is_mere
              (a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) HNO)) Ha)).2
   in
 (((let X1 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_fun (equiv_smalltype X) in
    let Ha :=
      X1 (a.1 < hartogs_number)
        (issmall_hprop (a.1 < hartogs_number)
           (ordinal_relation_is_mere a.1
              hartogs_number)) a.2 in
    ((a.1;
     transitive_card (card a.1) (card hartogs_number)
       (card A)
       (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
       HN);
    let X2 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      equiv_isequiv (equiv_smalltype X) in
    let X3 :=
      fun (X : Type) (IsSmall : IsSmall X) =>
      (equiv_smalltype X)^-1 in
    X3
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN) < HNO)
      (issmall_hprop
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN) < HNO)
         (ordinal_relation_is_mere
            (a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) HNO)) Ha)).1).1;
 let X1 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   equiv_isequiv (equiv_smalltype X) in
 let X2 :=
   fun (X : Type) (IsSmall : IsSmall X) =>
   (equiv_smalltype X)^-1 in
 X2
   (((let X3 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_fun (equiv_smalltype X) in
      let Ha :=
        X3 (a.1 < hartogs_number)
          (issmall_hprop (a.1 < hartogs_number)
             (ordinal_relation_is_mere a.1
                hartogs_number)) a.2 in
      ((a.1;
       transitive_card (card a.1)
         (card hartogs_number) (card A)
         (le_Cardinal_lt_Ordinal a.1 hartogs_number Ha)
         HN);
      let X4 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        equiv_isequiv (equiv_smalltype X) in
      let X5 :=
        fun (X : Type) (IsSmall : IsSmall X) =>
        (equiv_smalltype X)^-1 in
      X5
        ((a.1;
         transitive_card (card a.1)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a.1 hartogs_number
              Ha) HN) < HNO)
        (issmall_hprop
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (ordinal_relation_is_mere
              (a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) HNO)) Ha)).1).1 <
    hartogs_number)
   (issmall_hprop
      (((let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let Ha :=
           X3 (a.1 < hartogs_number)
             (issmall_hprop (a.1 < hartogs_number)
                (ordinal_relation_is_mere a.1
                   hartogs_number)) a.2 in
         ((a.1;
          transitive_card (card a.1)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a.1 hartogs_number
               Ha) HN);
         let X4 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X5 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X5
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN) < HNO)
           (issmall_hprop
              ((a.1;
               transitive_card (...) (...) (...) (...)
                 HN) < HNO)
              (ordinal_relation_is_mere
                 (a.1;
                 transitive_card (...) (...) (...)
                   (...) HN) HNO)) Ha)).1).1 <
       hartogs_number)
      (ordinal_relation_is_mere
         ((let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let Ha :=
             X3 (a.1 < hartogs_number)
               (issmall_hprop (a.1 < hartogs_number)
                  (ordinal_relation_is_mere a.1
                     hartogs_number)) a.2 in
           ((a.1;
            transitive_card (card a.1)
              (card hartogs_number) (card A)
              (le_Cardinal_lt_Ordinal a.1
                 hartogs_number Ha) HN);
           let X4 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X5 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X5
             ((a.1;
              transitive_card (card a.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a.1
                   hartogs_number Ha) HN) < HNO)
             (issmall_hprop
                ((a.1;
                 transitive_card (...) (...) (...)
                   (...) HN) < HNO)
                (ordinal_relation_is_mere
                   (a.1;
                   transitive_card (...) (...) (...)
                     (...) HN) HNO)) Ha)).1).1
         hartogs_number)) H)).1 = a.1 reflexivity.
      +univalence: Univalence
prop_resizing: PropResizing
lem: ExcludedMiddle
A: HSet
f: hartogs_number_carrier -> A
Hf: IsInjective f
HN: card hartogs_number ≤ card A
HNO:= (hartogs_number; HN): hartogs_number'
X: Isomorphism hartogs_number ↓hartogs_number
forall a a' : (↓hartogs_number).1,
(↓hartogs_number).2 a a' <->
(↓HNO).2
  (equiv_adjointify
     (fun X0 : ↓hartogs_number =>
      (fun (a0 : Ordinal)
         (Ha : smalltype (a0 < hartogs_number)) =>
       let X1 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let Ha0 :=
         X1 (a0 < hartogs_number)
           (issmall_hprop (a0 < hartogs_number)
              (ordinal_relation_is_mere a0
                 hartogs_number)) Ha in
       ((a0;
        transitive_card (card a0)
          (card hartogs_number) (card A)
          (le_Cardinal_lt_Ordinal a0 hartogs_number
             Ha0) HN);
       let X2 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X3
         ((a0;
          transitive_card (card a0)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a0 hartogs_number
               Ha0) HN) < HNO)
         (issmall_hprop
            ((a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)
            (ordinal_relation_is_mere
               (a0;
               transitive_card (card a0)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a0
                    hartogs_number Ha0) HN) HNO))
         (Ha0
          :
          (a0;
          transitive_card (card a0)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a0 hartogs_number
               Ha0) HN) < HNO))) X0.1 X0.2)
     (fun X0 : ↓HNO =>
      (fun proj1 : hartogs_number' =>
       (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
          (H : smalltype ((a0; Ha) < HNO)) =>
        let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H0 :=
          X1 ((a0; Ha) < HNO)
            (issmall_hprop ((a0; Ha) < HNO)
               (ordinal_relation_is_mere (a0; Ha) HNO))
            H in
        (a0;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 (a0 < hartogs_number)
          (issmall_hprop (a0 < hartogs_number)
             (ordinal_relation_is_mere a0
                hartogs_number)) H0)) proj1.1 proj1.2)
        X0.1 X0.2)
     ((fun a0 : ↓HNO =>
       path_sigma_hprop
         (let X0 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let Ha :=
            X0
              ((let X1 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X1 (((a0.1).1; (a0.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a0.2 in
                ((a0.1).1;
                let X2 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X3 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X3 ((a0.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1 <
               hartogs_number)
              (issmall_hprop
                 ((let X1 :=
                     fun (X : Type)
                       (IsSmall : IsSmall X) =>
                     equiv_fun (equiv_smalltype X) in
                   let H :=
                     X1 ((....1; ....2) < HNO)
                       (issmall_hprop (...) (...))
                       a0.2 in
                   ((a0.1).1;
                   let X2 :=
                     fun ... ... => equiv_isequiv ...
                     in
                   let X3 := ... => ...^-1 in
                   X3 (...) (...) H)).1 <
                  hartogs_number)
                 (ordinal_relation_is_mere
                    (let X1 :=
                       fun (X : Type)
                         (IsSmall : IsSmall X) =>
                       equiv_fun (equiv_smalltype X)
                       in
                     let H :=
                       X1 ((....1; ....2) < HNO)
                         (issmall_hprop (...) (...))
                         a0.2 in
                     ((a0.1).1;
                     let X2 :=
                       fun ... ... =>
                       equiv_isequiv ... in
                     let X3 := ... => ...^-1 in
                     X3 (...) (...) H)).1
                    hartogs_number))
              (let X1 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X1 (((a0.1).1; (a0.1).2) < HNO)
                   (issmall_hprop
                      (((a0.1).1; (a0.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a0.1).1; (a0.1).2) HNO))
                   a0.2 in
               ((a0.1).1;
               let X2 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X3 ((a0.1).1 < hartogs_number)
                 (issmall_hprop
                    ((a0.1).1 < hartogs_number)
                    (ordinal_relation_is_mere (a0.1).1
                       hartogs_number)) H)).2 in
          (((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X1 (((a0.1).1; (a0.1).2) < HNO)
                 (issmall_hprop
                    (((a0.1).1; (a0.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a0.1).1; (a0.1).2) HNO)) a0.2
               in
             ((a0.1).1;
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3 ((a0.1).1 < hartogs_number)
               (issmall_hprop
                  ((a0.1).1 < hartogs_number)
                  (ordinal_relation_is_mere (a0.1).1
                     hartogs_number)) H)).1;
           transitive_card
             (card
                (let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let H :=
                   X1 (((a0.1).1; (a0.1).2) < HNO)
                     (issmall_hprop (... < HNO)
                        (ordinal_relation_is_mere ...
                           HNO)) a0.2 in
                 ((a0.1).1;
                 let X2 :=
                   fun (X : Type) (IsSmall : ...) =>
                   equiv_isequiv (...) in
                 let X3 := fun ... ... => (...)^-1 in
                 X3 (....1 < hartogs_number)
                   (issmall_hprop ... ...) H)).1)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal
                (let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let H :=
                   X1 (((a0.1).1; (a0.1).2) < HNO)
                     (issmall_hprop (... < HNO)
                        (ordinal_relation_is_mere ...
                           HNO)) a0.2 in
                 ((a0.1).1;
                 let X2 :=
                   fun (X : Type) (IsSmall : ...) =>
                   equiv_isequiv (...) in
                 let X3 := fun ... ... => (...)^-1 in
                 X3 (....1 < hartogs_number)
                   (issmall_hprop ... ...) H)).1
                hartogs_number Ha) HN);
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X2
            (((let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (... < HNO)
                   (issmall_hprop ... ...) a0.2 in
               ((a0.1).1;
               let X4 := ... => ... in
               let X5 := ... in X5 ... ... H)).1;
             transitive_card
               (card
                  (let X3 := ... => ... in
                   let H := ... in (....1; ...)).1)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal
                  (let X3 := ... => ... in
                   let H := ... in (....1; ...)).1
                  hartogs_number Ha) HN) < HNO)
            (issmall_hprop
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let H := X3 ... ... a0.2 in
                  ((a0.1).1; ... ...)).1;
                transitive_card (card (... ...).1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal (... ...).1
                     hartogs_number Ha) HN) < HNO)
               (ordinal_relation_is_mere
                  ((let X3 :=
                      fun ... ... => equiv_fun ... in
                    let H := X3 ... ... a0.2 in
                    ((a0.1).1; ... ...)).1;
                  transitive_card (card (... ...).1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal
                       (... ...).1 hartogs_number Ha)
                    HN) HNO)) Ha)) a0
         (path_sigma_hprop
            (let X0 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X0
                 ((let X1 :=
                     fun (X : Type)
                       (IsSmall : IsSmall X) =>
                     equiv_fun (equiv_smalltype X) in
                   let H :=
                     X1 ((....1; ....2) < HNO)
                       (issmall_hprop (...) (...))
                       a0.2 in
                   ((a0.1).1;
                   let X2 :=
                     fun ... ... => equiv_isequiv ...
                     in
                   let X3 := ... => ...^-1 in
                   X3 (...) (...) H)).1 <
                  hartogs_number)
                 (issmall_hprop
                    ((let X1 :=
                        fun (X : Type) (IsSmall : ...)
                        => equiv_fun (...) in
                      let H := X1 (...) (...) a0.2 in
                      ((a0.1).1;
                      let X2 := ... in ... ...)).1 <
                     hartogs_number)
                    (ordinal_relation_is_mere
                       (let X1 :=
                          fun (X : Type)
                            (IsSmall : ...) =>
                          equiv_fun (...) in
                        let H := X1 (...) (...) a0.2
                          in
                        ((a0.1).1;
                        let X2 := ... in ... ...)).1
                       hartogs_number))
                 (let X1 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_fun (equiv_smalltype X) in
                  let H :=
                    X1 (((a0.1).1; (a0.1).2) < HNO)
                      (issmall_hprop
                         ((....1; ....2) < HNO)
                         (ordinal_relation_is_mere
                            (....1; ....2) HNO)) a0.2
                    in
                  ((a0.1).1;
                  let X2 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_isequiv (equiv_smalltype X)
                    in
                  let X3 :=
                    fun (X : Type) (IsSmall : ...) =>
                    (equiv_smalltype X)^-1 in
                  X3 ((a0.1).1 < hartogs_number)
                    (issmall_hprop (...) (...)) H)).2
               in
             (((let X1 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X1 (((a0.1).1; (a0.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a0.2 in
                ((a0.1).1;
                let X2 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X3 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X3 ((a0.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1;
              transitive_card
                (card
                   (let X1 :=
                      fun (X : Type)
                        (IsSmall : IsSmall X) =>
                      equiv_fun (equiv_smalltype X) in
                    let H :=
                      X1 (... < HNO)
                        (issmall_hprop ... ...) a0.2
                      in
                    ((a0.1).1;
                    let X2 := ... => ... in
                    let X3 := ... in X3 ... ... H)).1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal
                   (let X1 :=
                      fun (X : Type)
                        (IsSmall : IsSmall X) =>
                      equiv_fun (equiv_smalltype X) in
                    let H :=
                      X1 (... < HNO)
                        (issmall_hprop ... ...) a0.2
                      in
                    ((a0.1).1;
                    let X2 := ... => ... in
                    let X3 := ... in X3 ... ... H)).1
                   hartogs_number Ha) HN);
             let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X2
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let H := X3 ... ... a0.2 in
                  ((a0.1).1; ... ...)).1;
                transitive_card (card (... ...).1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal (... ...).1
                     hartogs_number Ha) HN) < HNO)
               (issmall_hprop
                  (((let X3 := ... in ... ...).1;
                   transitive_card (card ....1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal ....1
                        hartogs_number Ha) HN) < HNO)
                  (ordinal_relation_is_mere
                     ((let X3 := ... in ... ...).1;
                     transitive_card (card ....1)
                       (card hartogs_number) (card A)
                       (le_Cardinal_lt_Ordinal ....1
                          hartogs_number Ha) HN) HNO))
               Ha)).1 a0.1 1))
      :
      (fun X0 : ↓hartogs_number =>
       (fun (a0 : Ordinal)
          (Ha : smalltype (a0 < hartogs_number)) =>
        let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let Ha0 :=
          X1 (a0 < hartogs_number)
            (issmall_hprop (a0 < hartogs_number)
               (ordinal_relation_is_mere a0
                  hartogs_number)) Ha in
        ((a0;
         transitive_card (card a0)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a0 hartogs_number
              Ha0) HN);
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3
          ((a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN) < HNO)
          (issmall_hprop
             ((a0;
              transitive_card (...) (...) (...) (...)
                HN) < HNO)
             (ordinal_relation_is_mere
                (a0;
                transitive_card (...) (...) (...)
                  (...) HN) HNO))
          (Ha0
           :
           (a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN) < HNO))) X0.1 X0.2)
      o (fun X0 : ↓HNO =>
         (fun proj1 : hartogs_number' =>
          (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
             (H : smalltype ((a0; Ha) < HNO)) =>
           let X1 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H0 :=
             X1 ((a0; Ha) < HNO)
               (issmall_hprop ((a0; Ha) < HNO)
                  (ordinal_relation_is_mere (a0; Ha)
                     HNO)) H in
           (a0;
           let X2 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X3 (a0 < hartogs_number)
             (issmall_hprop (a0 < hartogs_number)
                (ordinal_relation_is_mere a0
                   hartogs_number)) H0)) proj1.1
            proj1.2) X0.1 X0.2) == idmap)
     ((fun a0 : ↓hartogs_number =>
       path_sigma_hprop
         (let X0 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X0
              ((((let X1 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_fun (equiv_smalltype X) in
                  let Ha :=
                    X1 (a0.1 < hartogs_number)
                      (issmall_hprop (...) (...)) a0.2
                    in
                  ((a0.1;
                   transitive_card (card a0.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a0.1
                        hartogs_number Ha) HN);
                  let X2 :=
                    fun ... ... => equiv_isequiv ...
                    in
                  let X3 := ... => ...^-1 in
                  X3 (...) (...) Ha)).1).1;
               ((let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let Ha :=
                   X1 (a0.1 < hartogs_number)
                     (issmall_hprop (...) (...)) a0.2
                   in
                 ((a0.1;
                  transitive_card (card a0.1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal a0.1
                       hartogs_number Ha) HN);
                 let X2 :=
                   fun ... ... => equiv_isequiv ... in
                 let X3 := ... => ...^-1 in
                 X3 (...) (...) Ha)).1).2) < HNO)
              (issmall_hprop
                 ((((let X1 :=
                       fun (X : Type) (IsSmall : ...)
                       => equiv_fun (...) in
                     let Ha := X1 (...) (...) a0.2 in
                     ((a0.1;
                      transitive_card ... ... ... ...
                        HN); let X2 := ... in ... ...)).1).1;
                  ((let X1 :=
                      fun (X : Type) (IsSmall : ...)
                      => equiv_fun (...) in
                    let Ha := X1 (...) (...) a0.2 in
                    ((a0.1;
                     transitive_card ... ... ... ...
                       HN); let X2 := ... in ... ...)).1).2) <
                  HNO)
                 (ordinal_relation_is_mere
                    (((let X1 :=
                         fun (X : Type)
                           (IsSmall : ...) =>
                         equiv_fun (...) in
                       let Ha := X1 (...) (...) a0.2
                         in
                       ((a0.1;
                        transitive_card ... ... ...
                          ... HN);
                       let X2 := ... in ... ...)).1).1;
                    ((let X1 :=
                        fun (X : Type) (IsSmall : ...)
                        => equiv_fun (...) in
                      let Ha := X1 (...) (...) a0.2 in
                      ((a0.1;
                       transitive_card ... ... ... ...
                         HN);
                      let X2 := ... in ... ...)).1).2)
                    HNO))
              (let X1 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let Ha :=
                 X1 (a0.1 < hartogs_number)
                   (issmall_hprop
                      (a0.1 < hartogs_number)
                      (ordinal_relation_is_mere a0.1
                         hartogs_number)) a0.2 in
               ((a0.1;
                transitive_card (card a0.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a0.1
                     hartogs_number Ha) HN);
               let X2 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X3
                 ((a0.1;
                  transitive_card (...) (...) (...)
                    (...) HN) < HNO)
                 (issmall_hprop ((a0.1; ...) < HNO)
                    (ordinal_relation_is_mere
                       (a0.1; ...) HNO)) Ha)).2 in
          (((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X1 (a0.1 < hartogs_number)
                 (issmall_hprop
                    (a0.1 < hartogs_number)
                    (ordinal_relation_is_mere a0.1
                       hartogs_number)) a0.2 in
             ((a0.1;
              transitive_card (card a0.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a0.1
                   hartogs_number Ha) HN);
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3
               ((a0.1;
                transitive_card (...) (...) (...)
                  (...) HN) < HNO)
               (issmall_hprop ((a0.1; ...) < HNO)
                  (ordinal_relation_is_mere
                     (a0.1; ...) HNO)) Ha)).1).1;
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X2
            (((let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let Ha :=
                 X3 (a0.1 < hartogs_number)
                   (issmall_hprop ... ...) a0.2 in
               ((a0.1;
                transitive_card (...) (...) (...)
                  (...) HN);
               let X4 := ... => ... in
               let X5 := ... in X5 ... ... Ha)).1).1 <
             hartogs_number)
            (issmall_hprop
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let Ha := X3 ... ... a0.2 in
                  ((a0.1; ...); ... ...)).1).1 <
                hartogs_number)
               (ordinal_relation_is_mere
                  ((let X3 :=
                      fun ... ... => equiv_fun ... in
                    let Ha := X3 ... ... a0.2 in
                    ((a0.1; ...); ... ...)).1).1
                  hartogs_number)) H)) a0 1)
      :
      (fun X0 : ↓HNO =>
       (fun proj1 : hartogs_number' =>
        (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
           (H : smalltype ((a0; Ha) < HNO)) =>
         let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H0 :=
           X1 ((a0; Ha) < HNO)
             (issmall_hprop ((a0; Ha) < HNO)
                (ordinal_relation_is_mere (a0; Ha) HNO))
             H in
         (a0;
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3 (a0 < hartogs_number)
           (issmall_hprop (a0 < hartogs_number)
              (ordinal_relation_is_mere a0
                 hartogs_number)) H0)) proj1.1 proj1.2)
         X0.1 X0.2)
      o (fun X0 : ↓hartogs_number =>
         (fun (a0 : Ordinal)
            (Ha : smalltype (a0 < hartogs_number)) =>
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let Ha0 :=
            X1 (a0 < hartogs_number)
              (issmall_hprop (a0 < hartogs_number)
                 (ordinal_relation_is_mere a0
                    hartogs_number)) Ha in
          ((a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN);
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X3
            ((a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)
            (issmall_hprop
               ((a0;
                transitive_card (...) (...) (...)
                  (...) HN) < HNO)
               (ordinal_relation_is_mere
                  (a0;
                  transitive_card (...) (...) (...)
                    (...) HN) HNO))
            (Ha0
             :
             (a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)))
           X0.1 X0.2) == idmap) a)
  (equiv_adjointify
     (fun X0 : ↓hartogs_number =>
      (fun (a0 : Ordinal)
         (Ha : smalltype (a0 < hartogs_number)) =>
       let X1 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_fun (equiv_smalltype X) in
       let Ha0 :=
         X1 (a0 < hartogs_number)
           (issmall_hprop (a0 < hartogs_number)
              (ordinal_relation_is_mere a0
                 hartogs_number)) Ha in
       ((a0;
        transitive_card (card a0)
          (card hartogs_number) (card A)
          (le_Cardinal_lt_Ordinal a0 hartogs_number
             Ha0) HN);
       let X2 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         equiv_isequiv (equiv_smalltype X) in
       let X3 :=
         fun (X : Type) (IsSmall : IsSmall X) =>
         (equiv_smalltype X)^-1 in
       X3
         ((a0;
          transitive_card (card a0)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a0 hartogs_number
               Ha0) HN) < HNO)
         (issmall_hprop
            ((a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)
            (ordinal_relation_is_mere
               (a0;
               transitive_card (card a0)
                 (card hartogs_number) (card A)
                 (le_Cardinal_lt_Ordinal a0
                    hartogs_number Ha0) HN) HNO))
         (Ha0
          :
          (a0;
          transitive_card (card a0)
            (card hartogs_number) (card A)
            (le_Cardinal_lt_Ordinal a0 hartogs_number
               Ha0) HN) < HNO))) X0.1 X0.2)
     (fun X0 : ↓HNO =>
      (fun proj1 : hartogs_number' =>
       (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
          (H : smalltype ((a0; Ha) < HNO)) =>
        let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let H0 :=
          X1 ((a0; Ha) < HNO)
            (issmall_hprop ((a0; Ha) < HNO)
               (ordinal_relation_is_mere (a0; Ha) HNO))
            H in
        (a0;
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3 (a0 < hartogs_number)
          (issmall_hprop (a0 < hartogs_number)
             (ordinal_relation_is_mere a0
                hartogs_number)) H0)) proj1.1 proj1.2)
        X0.1 X0.2)
     ((fun a0 : ↓HNO =>
       path_sigma_hprop
         (let X0 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let Ha :=
            X0
              ((let X1 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X1 (((a0.1).1; (a0.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a0.2 in
                ((a0.1).1;
                let X2 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X3 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X3 ((a0.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1 <
               hartogs_number)
              (issmall_hprop
                 ((let X1 :=
                     fun (X : Type)
                       (IsSmall : IsSmall X) =>
                     equiv_fun (equiv_smalltype X) in
                   let H :=
                     X1 ((....1; ....2) < HNO)
                       (issmall_hprop (...) (...))
                       a0.2 in
                   ((a0.1).1;
                   let X2 :=
                     fun ... ... => equiv_isequiv ...
                     in
                   let X3 := ... => ...^-1 in
                   X3 (...) (...) H)).1 <
                  hartogs_number)
                 (ordinal_relation_is_mere
                    (let X1 :=
                       fun (X : Type)
                         (IsSmall : IsSmall X) =>
                       equiv_fun (equiv_smalltype X)
                       in
                     let H :=
                       X1 ((....1; ....2) < HNO)
                         (issmall_hprop (...) (...))
                         a0.2 in
                     ((a0.1).1;
                     let X2 :=
                       fun ... ... =>
                       equiv_isequiv ... in
                     let X3 := ... => ...^-1 in
                     X3 (...) (...) H)).1
                    hartogs_number))
              (let X1 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X1 (((a0.1).1; (a0.1).2) < HNO)
                   (issmall_hprop
                      (((a0.1).1; (a0.1).2) < HNO)
                      (ordinal_relation_is_mere
                         ((a0.1).1; (a0.1).2) HNO))
                   a0.2 in
               ((a0.1).1;
               let X2 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X3 ((a0.1).1 < hartogs_number)
                 (issmall_hprop
                    ((a0.1).1 < hartogs_number)
                    (ordinal_relation_is_mere (a0.1).1
                       hartogs_number)) H)).2 in
          (((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let H :=
               X1 (((a0.1).1; (a0.1).2) < HNO)
                 (issmall_hprop
                    (((a0.1).1; (a0.1).2) < HNO)
                    (ordinal_relation_is_mere
                       ((a0.1).1; (a0.1).2) HNO)) a0.2
               in
             ((a0.1).1;
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3 ((a0.1).1 < hartogs_number)
               (issmall_hprop
                  ((a0.1).1 < hartogs_number)
                  (ordinal_relation_is_mere (a0.1).1
                     hartogs_number)) H)).1;
           transitive_card
             (card
                (let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let H :=
                   X1 (((a0.1).1; (a0.1).2) < HNO)
                     (issmall_hprop (... < HNO)
                        (ordinal_relation_is_mere ...
                           HNO)) a0.2 in
                 ((a0.1).1;
                 let X2 :=
                   fun (X : Type) (IsSmall : ...) =>
                   equiv_isequiv (...) in
                 let X3 := fun ... ... => (...)^-1 in
                 X3 (....1 < hartogs_number)
                   (issmall_hprop ... ...) H)).1)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal
                (let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let H :=
                   X1 (((a0.1).1; (a0.1).2) < HNO)
                     (issmall_hprop (... < HNO)
                        (ordinal_relation_is_mere ...
                           HNO)) a0.2 in
                 ((a0.1).1;
                 let X2 :=
                   fun (X : Type) (IsSmall : ...) =>
                   equiv_isequiv (...) in
                 let X3 := fun ... ... => (...)^-1 in
                 X3 (....1 < hartogs_number)
                   (issmall_hprop ... ...) H)).1
                hartogs_number Ha) HN);
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X2
            (((let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let H :=
                 X3 (... < HNO)
                   (issmall_hprop ... ...) a0.2 in
               ((a0.1).1;
               let X4 := ... => ... in
               let X5 := ... in X5 ... ... H)).1;
             transitive_card
               (card
                  (let X3 := ... => ... in
                   let H := ... in (....1; ...)).1)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal
                  (let X3 := ... => ... in
                   let H := ... in (....1; ...)).1
                  hartogs_number Ha) HN) < HNO)
            (issmall_hprop
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let H := X3 ... ... a0.2 in
                  ((a0.1).1; ... ...)).1;
                transitive_card (card (... ...).1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal (... ...).1
                     hartogs_number Ha) HN) < HNO)
               (ordinal_relation_is_mere
                  ((let X3 :=
                      fun ... ... => equiv_fun ... in
                    let H := X3 ... ... a0.2 in
                    ((a0.1).1; ... ...)).1;
                  transitive_card (card (... ...).1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal
                       (... ...).1 hartogs_number Ha)
                    HN) HNO)) Ha)) a0
         (path_sigma_hprop
            (let X0 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X0
                 ((let X1 :=
                     fun (X : Type)
                       (IsSmall : IsSmall X) =>
                     equiv_fun (equiv_smalltype X) in
                   let H :=
                     X1 ((....1; ....2) < HNO)
                       (issmall_hprop (...) (...))
                       a0.2 in
                   ((a0.1).1;
                   let X2 :=
                     fun ... ... => equiv_isequiv ...
                     in
                   let X3 := ... => ...^-1 in
                   X3 (...) (...) H)).1 <
                  hartogs_number)
                 (issmall_hprop
                    ((let X1 :=
                        fun (X : Type) (IsSmall : ...)
                        => equiv_fun (...) in
                      let H := X1 (...) (...) a0.2 in
                      ((a0.1).1;
                      let X2 := ... in ... ...)).1 <
                     hartogs_number)
                    (ordinal_relation_is_mere
                       (let X1 :=
                          fun (X : Type)
                            (IsSmall : ...) =>
                          equiv_fun (...) in
                        let H := X1 (...) (...) a0.2
                          in
                        ((a0.1).1;
                        let X2 := ... in ... ...)).1
                       hartogs_number))
                 (let X1 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_fun (equiv_smalltype X) in
                  let H :=
                    X1 (((a0.1).1; (a0.1).2) < HNO)
                      (issmall_hprop
                         ((....1; ....2) < HNO)
                         (ordinal_relation_is_mere
                            (....1; ....2) HNO)) a0.2
                    in
                  ((a0.1).1;
                  let X2 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_isequiv (equiv_smalltype X)
                    in
                  let X3 :=
                    fun (X : Type) (IsSmall : ...) =>
                    (equiv_smalltype X)^-1 in
                  X3 ((a0.1).1 < hartogs_number)
                    (issmall_hprop (...) (...)) H)).2
               in
             (((let X1 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_fun (equiv_smalltype X) in
                let H :=
                  X1 (((a0.1).1; (a0.1).2) < HNO)
                    (issmall_hprop
                       ((....1; ....2) < HNO)
                       (ordinal_relation_is_mere
                          (....1; ....2) HNO)) a0.2 in
                ((a0.1).1;
                let X2 :=
                  fun (X : Type) (IsSmall : IsSmall X)
                  => equiv_isequiv (equiv_smalltype X)
                  in
                let X3 :=
                  fun (X : Type) (IsSmall : ...) =>
                  (equiv_smalltype X)^-1 in
                X3 ((a0.1).1 < hartogs_number)
                  (issmall_hprop (...) (...)) H)).1;
              transitive_card
                (card
                   (let X1 :=
                      fun (X : Type)
                        (IsSmall : IsSmall X) =>
                      equiv_fun (equiv_smalltype X) in
                    let H :=
                      X1 (... < HNO)
                        (issmall_hprop ... ...) a0.2
                      in
                    ((a0.1).1;
                    let X2 := ... => ... in
                    let X3 := ... in X3 ... ... H)).1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal
                   (let X1 :=
                      fun (X : Type)
                        (IsSmall : IsSmall X) =>
                      equiv_fun (equiv_smalltype X) in
                    let H :=
                      X1 (... < HNO)
                        (issmall_hprop ... ...) a0.2
                      in
                    ((a0.1).1;
                    let X2 := ... => ... in
                    let X3 := ... in X3 ... ... H)).1
                   hartogs_number Ha) HN);
             let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X2
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let H := X3 ... ... a0.2 in
                  ((a0.1).1; ... ...)).1;
                transitive_card (card (... ...).1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal (... ...).1
                     hartogs_number Ha) HN) < HNO)
               (issmall_hprop
                  (((let X3 := ... in ... ...).1;
                   transitive_card (card ....1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal ....1
                        hartogs_number Ha) HN) < HNO)
                  (ordinal_relation_is_mere
                     ((let X3 := ... in ... ...).1;
                     transitive_card (card ....1)
                       (card hartogs_number) (card A)
                       (le_Cardinal_lt_Ordinal ....1
                          hartogs_number Ha) HN) HNO))
               Ha)).1 a0.1 1))
      :
      (fun X0 : ↓hartogs_number =>
       (fun (a0 : Ordinal)
          (Ha : smalltype (a0 < hartogs_number)) =>
        let X1 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_fun (equiv_smalltype X) in
        let Ha0 :=
          X1 (a0 < hartogs_number)
            (issmall_hprop (a0 < hartogs_number)
               (ordinal_relation_is_mere a0
                  hartogs_number)) Ha in
        ((a0;
         transitive_card (card a0)
           (card hartogs_number) (card A)
           (le_Cardinal_lt_Ordinal a0 hartogs_number
              Ha0) HN);
        let X2 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          equiv_isequiv (equiv_smalltype X) in
        let X3 :=
          fun (X : Type) (IsSmall : IsSmall X) =>
          (equiv_smalltype X)^-1 in
        X3
          ((a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN) < HNO)
          (issmall_hprop
             ((a0;
              transitive_card (...) (...) (...) (...)
                HN) < HNO)
             (ordinal_relation_is_mere
                (a0;
                transitive_card (...) (...) (...)
                  (...) HN) HNO))
          (Ha0
           :
           (a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN) < HNO))) X0.1 X0.2)
      o (fun X0 : ↓HNO =>
         (fun proj1 : hartogs_number' =>
          (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
             (H : smalltype ((a0; Ha) < HNO)) =>
           let X1 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_fun (equiv_smalltype X) in
           let H0 :=
             X1 ((a0; Ha) < HNO)
               (issmall_hprop ((a0; Ha) < HNO)
                  (ordinal_relation_is_mere (a0; Ha)
                     HNO)) H in
           (a0;
           let X2 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             equiv_isequiv (equiv_smalltype X) in
           let X3 :=
             fun (X : Type) (IsSmall : IsSmall X) =>
             (equiv_smalltype X)^-1 in
           X3 (a0 < hartogs_number)
             (issmall_hprop (a0 < hartogs_number)
                (ordinal_relation_is_mere a0
                   hartogs_number)) H0)) proj1.1
            proj1.2) X0.1 X0.2) == idmap)
     ((fun a0 : ↓hartogs_number =>
       path_sigma_hprop
         (let X0 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let H :=
            X0
              ((((let X1 :=
                    fun (X : Type)
                      (IsSmall : IsSmall X) =>
                    equiv_fun (equiv_smalltype X) in
                  let Ha :=
                    X1 (a0.1 < hartogs_number)
                      (issmall_hprop (...) (...)) a0.2
                    in
                  ((a0.1;
                   transitive_card (card a0.1)
                     (card hartogs_number) (card A)
                     (le_Cardinal_lt_Ordinal a0.1
                        hartogs_number Ha) HN);
                  let X2 :=
                    fun ... ... => equiv_isequiv ...
                    in
                  let X3 := ... => ...^-1 in
                  X3 (...) (...) Ha)).1).1;
               ((let X1 :=
                   fun (X : Type)
                     (IsSmall : IsSmall X) =>
                   equiv_fun (equiv_smalltype X) in
                 let Ha :=
                   X1 (a0.1 < hartogs_number)
                     (issmall_hprop (...) (...)) a0.2
                   in
                 ((a0.1;
                  transitive_card (card a0.1)
                    (card hartogs_number) (card A)
                    (le_Cardinal_lt_Ordinal a0.1
                       hartogs_number Ha) HN);
                 let X2 :=
                   fun ... ... => equiv_isequiv ... in
                 let X3 := ... => ...^-1 in
                 X3 (...) (...) Ha)).1).2) < HNO)
              (issmall_hprop
                 ((((let X1 :=
                       fun (X : Type) (IsSmall : ...)
                       => equiv_fun (...) in
                     let Ha := X1 (...) (...) a0.2 in
                     ((a0.1;
                      transitive_card ... ... ... ...
                        HN); let X2 := ... in ... ...)).1).1;
                  ((let X1 :=
                      fun (X : Type) (IsSmall : ...)
                      => equiv_fun (...) in
                    let Ha := X1 (...) (...) a0.2 in
                    ((a0.1;
                     transitive_card ... ... ... ...
                       HN); let X2 := ... in ... ...)).1).2) <
                  HNO)
                 (ordinal_relation_is_mere
                    (((let X1 :=
                         fun (X : Type)
                           (IsSmall : ...) =>
                         equiv_fun (...) in
                       let Ha := X1 (...) (...) a0.2
                         in
                       ((a0.1;
                        transitive_card ... ... ...
                          ... HN);
                       let X2 := ... in ... ...)).1).1;
                    ((let X1 :=
                        fun (X : Type) (IsSmall : ...)
                        => equiv_fun (...) in
                      let Ha := X1 (...) (...) a0.2 in
                      ((a0.1;
                       transitive_card ... ... ... ...
                         HN);
                      let X2 := ... in ... ...)).1).2)
                    HNO))
              (let X1 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let Ha :=
                 X1 (a0.1 < hartogs_number)
                   (issmall_hprop
                      (a0.1 < hartogs_number)
                      (ordinal_relation_is_mere a0.1
                         hartogs_number)) a0.2 in
               ((a0.1;
                transitive_card (card a0.1)
                  (card hartogs_number) (card A)
                  (le_Cardinal_lt_Ordinal a0.1
                     hartogs_number Ha) HN);
               let X2 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_isequiv (equiv_smalltype X)
                 in
               let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => (equiv_smalltype X)^-1 in
               X3
                 ((a0.1;
                  transitive_card (...) (...) (...)
                    (...) HN) < HNO)
                 (issmall_hprop ((a0.1; ...) < HNO)
                    (ordinal_relation_is_mere
                       (a0.1; ...) HNO)) Ha)).2 in
          (((let X1 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_fun (equiv_smalltype X) in
             let Ha :=
               X1 (a0.1 < hartogs_number)
                 (issmall_hprop
                    (a0.1 < hartogs_number)
                    (ordinal_relation_is_mere a0.1
                       hartogs_number)) a0.2 in
             ((a0.1;
              transitive_card (card a0.1)
                (card hartogs_number) (card A)
                (le_Cardinal_lt_Ordinal a0.1
                   hartogs_number Ha) HN);
             let X2 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               equiv_isequiv (equiv_smalltype X) in
             let X3 :=
               fun (X : Type) (IsSmall : IsSmall X) =>
               (equiv_smalltype X)^-1 in
             X3
               ((a0.1;
                transitive_card (...) (...) (...)
                  (...) HN) < HNO)
               (issmall_hprop ((a0.1; ...) < HNO)
                  (ordinal_relation_is_mere
                     (a0.1; ...) HNO)) Ha)).1).1;
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X2
            (((let X3 :=
                 fun (X : Type) (IsSmall : IsSmall X)
                 => equiv_fun (equiv_smalltype X) in
               let Ha :=
                 X3 (a0.1 < hartogs_number)
                   (issmall_hprop ... ...) a0.2 in
               ((a0.1;
                transitive_card (...) (...) (...)
                  (...) HN);
               let X4 := ... => ... in
               let X5 := ... in X5 ... ... Ha)).1).1 <
             hartogs_number)
            (issmall_hprop
               (((let X3 :=
                    fun ... ... => equiv_fun ... in
                  let Ha := X3 ... ... a0.2 in
                  ((a0.1; ...); ... ...)).1).1 <
                hartogs_number)
               (ordinal_relation_is_mere
                  ((let X3 :=
                      fun ... ... => equiv_fun ... in
                    let Ha := X3 ... ... a0.2 in
                    ((a0.1; ...); ... ...)).1).1
                  hartogs_number)) H)) a0 1)
      :
      (fun X0 : ↓HNO =>
       (fun proj1 : hartogs_number' =>
        (fun (a0 : Ordinal) (Ha : card a0 ≤ card A)
           (H : smalltype ((a0; Ha) < HNO)) =>
         let X1 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_fun (equiv_smalltype X) in
         let H0 :=
           X1 ((a0; Ha) < HNO)
             (issmall_hprop ((a0; Ha) < HNO)
                (ordinal_relation_is_mere (a0; Ha) HNO))
             H in
         (a0;
         let X2 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           equiv_isequiv (equiv_smalltype X) in
         let X3 :=
           fun (X : Type) (IsSmall : IsSmall X) =>
           (equiv_smalltype X)^-1 in
         X3 (a0 < hartogs_number)
           (issmall_hprop (a0 < hartogs_number)
              (ordinal_relation_is_mere a0
                 hartogs_number)) H0)) proj1.1 proj1.2)
         X0.1 X0.2)
      o (fun X0 : ↓hartogs_number =>
         (fun (a0 : Ordinal)
            (Ha : smalltype (a0 < hartogs_number)) =>
          let X1 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_fun (equiv_smalltype X) in
          let Ha0 :=
            X1 (a0 < hartogs_number)
              (issmall_hprop (a0 < hartogs_number)
                 (ordinal_relation_is_mere a0
                    hartogs_number)) Ha in
          ((a0;
           transitive_card (card a0)
             (card hartogs_number) (card A)
             (le_Cardinal_lt_Ordinal a0 hartogs_number
                Ha0) HN);
          let X2 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            equiv_isequiv (equiv_smalltype X) in
          let X3 :=
            fun (X : Type) (IsSmall : IsSmall X) =>
            (equiv_smalltype X)^-1 in
          X3
            ((a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)
            (issmall_hprop
               ((a0;
                transitive_card (...) (...) (...)
                  (...) HN) < HNO)
               (ordinal_relation_is_mere
                  (a0;
                  transitive_card (...) (...) (...)
                    (...) HN) HNO))
            (Ha0
             :
             (a0;
             transitive_card (card a0)
               (card hartogs_number) (card A)
               (le_Cardinal_lt_Ordinal a0
                  hartogs_number Ha0) HN) < HNO)))
           X0.1 X0.2) == idmap) a') reflexivity.
  Defined.

End Hartogs_Number.