(** * The cumulative hierarchy [V]. *)

Require Import HoTT.Basics HoTT.Types.
[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import HSet TruncType.
Require Import Colimits.SpanPushout.
Require Import HoTT.Truncations.Core Colimits.Quotient.
Local Open Scope nat_scope.
Local Open Scope path_scope.

(** Bitotal relation *)

Definition bitotal {A B : Type} (R : A -> B -> HProp) :=
   (forall a : A, hexists (fun (b : B) => R a b))
 * (forall b : B, hexists (fun (a : A) => R a b)).

(** ** The cumulative hierarchy V *)

Module Export CumulativeHierarchy.

Private Inductive V@{U' U | U < U'} : Type@{U'} :=
| set {A : Type@{U}} (f : A -> V) : V.

Axiom setext : forall {A B : Type} (R : A -> B -> HProp)
  (bitot_R : bitotal R) (h : SPushout R -> V),
set (h o (spushl R)) = set (h o (spushr R)).

Axiom ishset_V : IsHSet V.
Existing Instance ishset_V.

(** The induction principle.  Annotating the universes here greatly reduces the number of universe variables later in the file.  For example, [function] below went from 279 to 3.  If [V_ind] needs to be generalized in the future, check [function] to make sure things haven't exploded again. *)
Fixpoint V_ind@{U' U u | U < U'} (P : V@{U' U} -> Type@{u})
  (H_0trunc : forall v : V@{U' U}, IsTrunc 0 (P v))
  (H_set : forall (A : Type@{U}) (f : A -> V) (H_f : forall a : A, P (f a)), P (set f))
  (H_setext : forall (A B : Type@{U}) (R : A -> B -> HProp@{U}) (bitot_R : bitotal R)
    (h : SPushout R -> V) (H_h : forall x : SPushout R, P (h x)),
    transport@{U' u} _ (setext R bitot_R h) (H_set A (h o spushl R) (H_h oD spushl R))
      = H_set B (h o spushr R) (H_h oD spushr R) )
  (v : V)
: P v
:= (match v with
     | set A f => fun _ _ => H_set A f (fun a => V_ind P H_0trunc H_set H_setext (f a))
    end) H_setext H_0trunc.

(** We don't need to axiomatize the computation rule because we get it for free thanks to 0-truncation *)

End CumulativeHierarchy.

Definition V_comp_setext (P : V -> Type)
  (H_0trunc : forall v : V, IsTrunc 0 (P v))
  (H_set : forall (A : Type) (f : A -> V) (H_f : forall a : A, P (f a)), P (set f))
  (H_setext : forall (A B : Type) (R : A -> B -> HProp) (bitot_R : bitotal R)
    (h : SPushout R -> V) (H_h : forall x : SPushout R, P (h x)),
    (setext R bitot_R h) # (H_set A (h o spushl R) (H_h oD spushl R))
      = H_set B (h o spushr R) (H_h oD spushr R) )
  (A B : Type) (R : A -> B -> HProp) (bitot_R : bitotal R) (h : SPushout R -> V)
: apD (V_ind P H_0trunc H_set H_setext) (setext R bitot_R h)
  = H_setext A B R bitot_R h ((V_ind P H_0trunc H_set H_setext) oD h).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext: forall (A B : Type) (R : A -> B -> HProp)
(bitot_R : bitotal R)
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : forall
       x : SPushout
             (fun (x : A) (x0 : B) =>
              R x x0), 
       P (h x)),
transport P (setext R bitot_R h)
  (H_set A
     (h
      o spushl
          (fun (x : A) (x0 : B) => R x x0))
     (H_h
      oD spushl
           (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   oD spushr
        (fun (x : A) (x0 : B) => R x x0))
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
apD (V_ind P H_0trunc H_set H_setext)
  (setext R bitot_R h) =
H_setext A B R bitot_R h
  (V_ind P H_0trunc H_set H_setext oD h)
Proof.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext: forall (A B : Type) (R : A -> B -> HProp)
(bitot_R : bitotal R)
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : forall
       x : SPushout
             (fun (x : A) (x0 : B) =>
              R x x0), 
       P (h x)),
transport P (setext R bitot_R h)
  (H_set A
     (h
      o spushl
          (fun (x : A) (x0 : B) => R x x0))
     (H_h
      oD spushl
           (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   oD spushr
        (fun (x : A) (x0 : B) => R x x0))
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
apD (V_ind P H_0trunc H_set H_setext)
  (setext R bitot_R h) =
H_setext A B R bitot_R h
  (V_ind P H_0trunc H_set H_setext oD h)
  apply path_ishprop.
Defined.

(** The non-dependent eliminator *)

Definition V_rec (P : Type)
  (H_0trunc : IsTrunc 0 P)
  (H_set : forall (A : Type), (A -> V) -> (A -> P) -> P)
  (H_setext : forall (A B : Type) (R : A -> B -> HProp) (bitot_R : bitotal R)
    (h : SPushout R -> V) (H_h : SPushout R -> P),
    H_set A (h o spushl R) (H_h o spushl R) = H_set B (h o spushr R) (H_h o spushr R) )
: V -> P.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
V -> P
Proof.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
V -> P
  refine (V_ind _ _ H_set _).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
forall (A B : Type) (R : A -> B -> HProp)
(bitot_R : bitotal R)
(h : SPushout (fun (x : A) (x0 : B) => R x x0) -> V)
(H_h : SPushout (fun (x : A) (x0 : B) => R x x0) -> P),
transport (fun _ : V => P) (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  intros.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
transport (fun _ : V => P) (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0)) exact (transport_const _ _ @ H_setext A B R bitot_R h H_h).
Defined.

Definition V_comp_nd_setext (P : Type)
  (H_0trunc : IsTrunc 0 P)
  (H_set : forall (A : Type), (A -> V) -> (A -> P) -> P)
  (H_setext : forall (A B : Type) (R : A -> B -> HProp) (bitot_R : bitotal R)
    (h : SPushout R -> V) (H_h : SPushout R -> P),
    H_set A (h o spushl R) (H_h o spushl R) = H_set B (h o spushr R) (H_h o spushr R) )
  (A B : Type) (R : A -> B -> HProp) (bitot_R : bitotal R) (h : SPushout R -> V)
: ap (V_rec P H_0trunc H_set H_setext) (setext R bitot_R h)
  = H_setext A B R bitot_R h ((V_rec P H_0trunc H_set H_setext) o h).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
ap (V_rec P H_0trunc H_set H_setext)
  (setext R bitot_R h) =
H_setext A B R bitot_R h
  (V_rec P H_0trunc H_set H_setext o h)
Proof.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext: forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout
       (fun (x : A) (x0 : B) => R x x0) ->
     V)
(H_h : SPushout
         (fun (x : A) (x0 : B) => R x x0) ->
       P),
H_set A
  (h
   o spushl
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushl
       (fun (x : A) (x0 : B) => R x x0)) =
H_set B
  (h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
  (H_h
   o spushr
       (fun (x : A) (x0 : B) => R x x0))
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
ap (V_rec P H_0trunc H_set H_setext)
  (setext R bitot_R h) =
H_setext A B R bitot_R h
  (V_rec P H_0trunc H_set H_setext o h)
  apply path_ishprop.
Defined.


(** ** Alternative induction principle (This is close to the one from the book) *)

Definition equal_img {A B C : Type} (f : A -> C) (g : B -> C) :=
   (forall a : A, hexists (fun (b : B) => f a = g b))
 * (forall b : B, hexists (fun (a : A) => f a = g b)).

Definition setext' {A B : Type} (f : A -> V) (g : B -> V) (eq_img : equal_img f g)
: set f = set g.
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
set f = set g
Proof.
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
set f = set g
  pose (R := fun a b => Build_HProp (f a = g b)).
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
R:= fun (a : A) (b : B) => Build_HProp (f a = g b): A -> B -> HProp
set f = set g
  pose (h := spushout_rec R V f g (fun _ _ r => r)).
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
R:= fun (a : A) (b : B) => Build_HProp (f a = g b): A -> B -> HProp
h:= spushout_rec (fun (a : A) (b : B) => R a b) V f g
  (fun (x : A) (y : B) => idmap): SPushout (fun (a : A) (b : B) => R a b) -> V
set f = set g
  exact (setext R eq_img h).
Defined.

Definition V_rec' (P : Type)
  (H_0trunc : IsTrunc 0 P)
  (H_set : forall (A : Type), (A -> V) -> (A -> P) -> P)
  (H_setext' : forall (A B : Type) (f : A -> V) (g : B -> V), (equal_img f g) ->
    forall (H_f : A -> P) (H_g : B -> P), (equal_img H_f H_g) ->
    (H_set A f H_f) = (H_set B g H_g) )
: V -> P.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
V -> P
Proof.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
V -> P
  refine (V_rec _ _ H_set _).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
forall (A B : Type) (R : A -> B -> HProp),
bitotal R ->
forall
(h : SPushout (fun (x : A) (x0 : B) => R x x0) -> V)
(H_h : SPushout (fun (x : A) (x0 : B) => R x x0) -> P),
H_set A
  (fun x : A =>
   h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : A =>
   H_h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x)) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   H_h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  intros A B R bitot_R h H_h.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
H_set A
  (fun x : A =>
   h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : A =>
   H_h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x)) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   H_h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  apply H_setext'.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
equal_img
  (fun x : A =>
   h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
equal_img
  (fun x : A =>
   H_h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   H_h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  -
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
equal_img
  (fun x : A =>
   h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x)) split.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall a : A,
hexists
  (fun b : B =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b))
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall b : B,
hexists
  (fun a : A =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b))
    +
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall a : A,
hexists
  (fun b : B =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) intro a.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
hexists
  (fun b : B =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) generalize (fst bitot_R a).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
hexists (fun b : B => R a b) ->
hexists
  (fun b : B =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) apply (Trunc_functor (-1)).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
{b : B & R a b} ->
{b : B &
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b)}
      intros [b r].
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
b: B
r: R a b
{b : B &
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b)} exists b.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
b: B
r: R a b
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b) exact (ap h (spglue R r)).
    +
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall b : B,
hexists
  (fun a : A =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) intro b.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
hexists
  (fun a : A =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) generalize (snd bitot_R b).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
hexists (fun a : A => R a b) ->
hexists
  (fun a : A =>
   h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   h (spushr (fun (x : A) (x0 : B) => R x x0) b)) apply (Trunc_functor (-1)).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
{a : A & R a b} ->
{a : A &
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b)}
      intros [a r].
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
a: A
r: R a b
{a : A &
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b)} exists a.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
a: A
r: R a b
h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
h (spushr (fun (x : A) (x0 : B) => R x x0) b) exact (ap h (spglue R r)).
  -
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
equal_img
  (fun x : A =>
   H_h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   H_h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x)) split.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall a : A,
hexists
  (fun b : B =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b))
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall b : B,
hexists
  (fun a : A =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b))
    +
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall a : A,
hexists
  (fun b : B =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) intro a.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
hexists
  (fun b : B =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) generalize (fst bitot_R a).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
hexists (fun b : B => R a b) ->
hexists
  (fun b : B =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) apply (Trunc_functor (-1)).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
{b : B & R a b} ->
{b : B &
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)}
      intros [b r].
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
b: B
r: R a b
{b : B &
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)} exists b.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
a: A
b: B
r: R a b
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b) exact (ap H_h (spglue R r)).
    +
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
forall b : B,
hexists
  (fun a : A =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) intro b.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
hexists
  (fun a : A =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) generalize (snd bitot_R b).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
hexists (fun a : A => R a b) ->
hexists
  (fun a : A =>
   H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
   H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)) apply (Trunc_functor (-1)).
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
{a : A & R a b} ->
{a : A &
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)}
      intros [a r].
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
a: A
r: R a b
{a : A &
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b)} exists a.
P: Type
H_0trunc: IsHSet P
H_set: forall A : Type, (A -> V) -> (A -> P) -> P
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V),
equal_img f g ->
forall (H_f : A -> P) (H_g : B -> P),
equal_img H_f H_g ->
H_set A f H_f = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: SPushout (fun (x : A) (x0 : B) => R x x0) -> P
b: B
a: A
r: R a b
H_h (spushl (fun (x : A) (x0 : B) => R x x0) a) =
H_h (spushr (fun (x : A) (x0 : B) => R x x0) b) exact (ap H_h (spglue R r)).
Defined.

(** Note that the hypothesis H_setext' differs from the one given in section 10.5 of the HoTT book. *)
Definition V_ind' (P : V -> Type)
  (H_0trunc : forall v : V, IsTrunc 0 (P v))
  (H_set : forall (A : Type) (f : A -> V) (H_f : forall a : A, P (f a)), P (set f))
  (H_setext' : forall (A B : Type) (f : A -> V) (g : B -> V)
    (eq_img: equal_img f g)
    (H_f : forall a : A, P (f a)) (H_g : forall b : B, P (g b))
    (H_eqimg : (forall a : A, hexists (fun (b : B) =>
                  hexists (fun (p:f a = g b) => p # (H_f a) = H_g b)))
             * (forall b : B, hexists (fun (a : A) =>
                  hexists (fun (p:f a = g b) => p # (H_f a) = H_g b))) ),
    (setext' f g eq_img) # (H_set A f H_f) = (H_set B g H_g)
  )
: forall v : V, P v.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
forall v : V, P v
Proof.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
forall v : V, P v
  apply V_ind with H_set; try assumption.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
forall (A B : Type) (R : A -> B -> HProp)
(bitot_R : bitotal R)
(h : SPushout (fun (x : A) (x0 : B) => R x x0) -> V)
(H_h : forall
       x : SPushout (fun (x : A) (x0 : B) => R x x0),
       P (h x)),
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  intros A B R bitot_R h H_h.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  pose (f := h o spushl R : A -> V ).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  pose (g := h o spushr R : B -> V ).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  pose (H_f := H_h oD spushl R : forall a : A, P (f a)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  pose (H_g := H_h oD spushr R : forall b : B, P (g b)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  assert (eq_img : equal_img f g).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
equal_img f g
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  {
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
equal_img f g split.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
forall a : A, hexists (fun b : B => f a = g b)
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
forall b : B, hexists (fun a : A => f a = g b)
    -
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
forall a : A, hexists (fun b : B => f a = g b) intro a.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
a: A
hexists (fun b : B => f a = g b) generalize (fst bitot_R a).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
a: A
hexists (fun b : B => R a b) ->
hexists (fun b : B => f a = g b) apply (Trunc_functor (-1)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
a: A
{b : B & R a b} -> {b : B & f a = g b}
      intros [b r].
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
a: A
b: B
r: R a b
{b : B & f a = g b} exists b.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
a: A
b: B
r: R a b
f a = g b exact (ap h (spglue R r)).
    -
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
forall b : B, hexists (fun a : A => f a = g b) intro b.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
b: B
hexists (fun a : A => f a = g b) generalize (snd bitot_R b).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
b: B
hexists (fun a : A => R a b) ->
hexists (fun a : A => f a = g b) apply (Trunc_functor (-1)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
b: B
{a : A & R a b} -> {a : A & f a = g b}
      intros [a r].
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
b: B
a: A
r: R a b
{a : A & f a = g b} exists a.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
b: B
a: A
r: R a b
f a = g b exact (ap h (spglue R r)). }
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  transitivity (transport P (setext' (h o spushl R) (h o spushr R) eq_img)
      (H_set A (h o spushl R) (H_h oD spushl R))).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
transport P
  (setext'
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (h o spushr (fun (x : A) (x0 : B) => R x x0))
     eq_img)
  (H_set A
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0)))
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P
  (setext'
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (h o spushr (fun (x : A) (x0 : B) => R x x0))
     eq_img)
  (H_set A
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  {
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
transport P
  (setext'
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (h o spushr (fun (x : A) (x0 : B) => R x x0))
     eq_img)
  (H_set A
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) apply (ap (fun p => transport P p (H_set A (h o spushl R) (H_h oD spushl R)))).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
setext R bitot_R h =
setext'
  (fun x : A =>
   h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  eq_img
    apply path_ishprop. }
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
transport P
  (setext'
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (h o spushr (fun (x : A) (x0 : B) => R x x0))
     eq_img)
  (H_set A
     (h o spushl (fun (x : A) (x0 : B) => R x x0))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  apply (H_setext' A B f g eq_img H_f H_g).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b)))  split.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
forall a : A,
hexists
  (fun b : B =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
forall b : B,
hexists
  (fun a : A =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
  -
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
forall a : A,
hexists
  (fun b : B =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b)) intro a.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
hexists
  (fun b : B =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
    set (truncb := fst bitot_R a).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
hexists
  (fun b : B =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b)) generalize truncb.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
hexists (fun b : B => R a b) ->
hexists
  (fun b : B =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
    apply (Trunc_functor (-1)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
{b : B & R a b} ->
{b : B &
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)}
    intros [b Rab].
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
{b : B &
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)} exists b.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)
    apply tr.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
{p : f a = g b & transport P p (H_f a) = H_g b}
    exists (ap h (spglue R Rab)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) = H_g b
    rhs_V napply (apD H_h (spglue R Rab)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) =
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a))
    apply inverse.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a)) =
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) unfold f, g.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
a: A
truncb:= fst bitot_R a: hexists (fun b : B => R a b)
b: B
Rab: R a b
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a)) =
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) apply transport_compose.
  -
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
forall b : B,
hexists
  (fun a : A =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b)) intros b.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
hexists
  (fun a : A =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
    set (trunca := snd bitot_R b).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
hexists
  (fun a : A =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b)) generalize trunca.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
hexists (fun a : A => R a b) ->
hexists
  (fun a : A =>
   hexists
     (fun p : f a = g b =>
      transport P p (H_f a) = H_g b))
    apply (Trunc_functor (-1)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
{a : A & R a b} ->
{a : A &
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)}
    intros [a Rab].
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
{a : A &
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)} exists a.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
hexists
  (fun p : f a = g b => transport P p (H_f a) = H_g b)
    apply tr.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
{p : f a = g b & transport P p (H_f a) = H_g b}
    exists (ap h (spglue R Rab)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) = H_g b
    rhs_V napply (apD H_h (spglue R Rab)).
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) =
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a))
    apply inverse.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a)) =
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) unfold f, g.
P: V -> Type
H_0trunc: forall v : V, IsHSet (P v)
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
H_setext': forall (A B : Type) (f : A -> V)
(g : B -> V) (eq_img : equal_img f g)
(H_f : forall a : A, P (f a))
(H_g : forall b : B, P (g b)),
(forall a : A,
 hexists
   (fun b : B =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) *
(forall b : B,
 hexists
   (fun a : A =>
    hexists
      (fun p : f a = g b =>
       transport P p (H_f a) = H_g b))) ->
transport P (setext' f g eq_img)
  (H_set A f H_f) = H_set B g H_g
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
f:= h o spushl (fun (x : A) (x0 : B) => R x x0)
:
A -> V: A -> V
g:= h o spushr (fun (x : A) (x0 : B) => R x x0)
:
B -> V: B -> V
H_f:= H_h oD spushl (fun (x : A) (x0 : B) => R x x0)
:
forall a : A, P (f a): forall a : A, P (f a)
H_g:= H_h oD spushr (fun (x : A) (x0 : B) => R x x0)
:
forall b : B, P (g b): forall b : B, P (g b)
eq_img: equal_img f g
b: B
trunca:= snd bitot_R b: hexists (fun a : A => R a b)
a: A
Rab: R a b
transport
  (fun x : SPushout (fun (x : A) (x0 : B) => R x x0)
   => P (h x))
  (spglue (fun (x : A) (x0 : B) => R x x0) Rab)
  (H_h (spushl (fun (x : A) (x0 : B) => R x x0) a)) =
transport P
  (ap h (spglue (fun (x : A) (x0 : B) => R x x0) Rab))
  (H_f a) apply transport_compose.
Defined.


(** Simpler induction principle when the goal is an hprop *)

Definition V_ind_hprop (P : V -> Type)
  (H_set : forall (A : Type) (f : A -> V) (H_f : forall a : A, P (f a)), P (set f))
  (isHProp_P : forall v : V, IsHProp (P v))
  : forall v : V, P v.
P: V -> Type
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
isHProp_P: forall v : V, IsHProp (P v)
forall v : V, P v
Proof.
P: V -> Type
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
isHProp_P: forall v : V, IsHProp (P v)
forall v : V, P v
  refine (V_ind _ _ H_set _).
P: V -> Type
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
isHProp_P: forall v : V, IsHProp (P v)
forall (A B : Type) (R : A -> B -> HProp)
(bitot_R : bitotal R)
(h : SPushout (fun (x : A) (x0 : B) => R x x0) -> V)
(H_h : forall
       x : SPushout (fun (x : A) (x0 : B) => R x x0),
       P (h x)),
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0))
  intros.
P: V -> Type
H_set: forall (A : Type) (f : A -> V),
(forall a : A, P (f a)) -> P (set f)
isHProp_P: forall v : V, IsHProp (P v)
A, B: Type
R: A -> B -> HProp
bitot_R: bitotal R
h: SPushout (fun (x : A) (x0 : B) => R x x0) -> V
H_h: forall
x : SPushout (fun (x : A) (x0 : B) => R x x0),
P (h x)
transport P (setext R bitot_R h)
  (H_set A
     (fun x : A =>
      h (spushl (fun (x0 : A) (x1 : B) => R x0 x1) x))
     (H_h oD spushl (fun (x : A) (x0 : B) => R x x0))) =
H_set B
  (fun x : B =>
   h (spushr (fun (x0 : A) (x1 : B) => R x0 x1) x))
  (H_h oD spushr (fun (x : A) (x0 : B) => R x x0)) apply path_ishprop.
Defined.


Section AssumingUA.
Context `{ua : Univalence}.

(** ** Membership relation *)

Definition mem (x : V) : V -> HProp.
ua: Univalence
x: V
V -> HProp
Proof.
ua: Univalence
x: V
V -> HProp
  simple refine (V_rec' _ _ _ _).
ua: Univalence
x: V
forall A : Type, (A -> V) -> (A -> HProp) -> HProp
ua: Univalence
x: V
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> HProp) (H_g : B -> HProp),
equal_img H_f H_g -> ?H_set A f H_f = ?H_set B g H_g
  -
ua: Univalence
x: V
forall A : Type, (A -> V) -> (A -> HProp) -> HProp intros A f _.
ua: Univalence
x: V
A: Type
f: A -> V
HProp
    exact (hexists (fun a : A => f a = x)).
  -
ua: Univalence
x: V
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> HProp) (H_g : B -> HProp),
equal_img H_f H_g ->
(fun (A0 : Type) (f0 : A0 -> V) (_ : A0 -> HProp) =>
 hexists (fun a : A0 => f0 a = x)) A f H_f =
(fun (A0 : Type) (f0 : A0 -> V) (_ : A0 -> HProp) =>
 hexists (fun a : A0 => f0 a = x)) B g H_g simpl.
ua: Univalence
x: V
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> HProp) (H_g : B -> HProp),
equal_img H_f H_g ->
hexists (fun a : A => f a = x) =
hexists (fun a : B => g a = x)
    intros A B f g eqimg _ _ _.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
hexists (fun a : A => f a = x) =
hexists (fun a : B => g a = x)
    apply path_iff_hprop; simpl.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
Tr (-1) {a : A & f a = x} -> Tr (-1) {a : B & g a = x}
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
Tr (-1) {a : B & g a = x} -> Tr (-1) {a : A & f a = x}
    +
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
Tr (-1) {a : A & f a = x} -> Tr (-1) {a : B & g a = x} intro H.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
Tr (-1) {a : B & g a = x} refine (Trunc_rec _ H).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
{a : A & f a = x} -> Tr (-1) {a : B & g a = x}
    intros [a p].
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
a: A
p: f a = x
Tr (-1) {a : B & g a = x} generalize (fst eqimg a).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
a: A
p: f a = x
hexists (fun b : B => f a = g b) ->
Tr (-1) {a : B & g a = x} apply (Trunc_functor (-1)).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
a: A
p: f a = x
{b : B & f a = g b} -> {a : B & g a = x}
    intros [b p'].
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
a: A
p: f a = x
b: B
p': f a = g b
{a : B & g a = x} exists b.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : A & f a = x}
a: A
p: f a = x
b: B
p': f a = g b
g b = x transitivity (f a); auto with path_hints.
    +
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
Tr (-1) {a : B & g a = x} -> Tr (-1) {a : A & f a = x} intro H.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
Tr (-1) {a : A & f a = x} refine (Trunc_rec _ H).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
{a : B & g a = x} -> Tr (-1) {a : A & f a = x}
      intros [b p].
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
b: B
p: g b = x
Tr (-1) {a : A & f a = x} generalize (snd eqimg b).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
b: B
p: g b = x
hexists (fun a : A => f a = g b) ->
Tr (-1) {a : A & f a = x} apply (Trunc_functor (-1)).
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
b: B
p: g b = x
{a : A & f a = g b} -> {a : A & f a = x}
      intros [a p'].
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
b: B
p: g b = x
a: A
p': f a = g b
{a : A & f a = x} exists a.
ua: Univalence
x: V
A, B: Type
f: A -> V
g: B -> V
eqimg: equal_img f g
H: Tr (-1) {a : B & g a = x}
b: B
p: g b = x
a: A
p': f a = g b
f a = x transitivity (g b); auto with path_hints.
Defined.

Declare Scope set_scope.
Notation "x ∈ v" := (mem x v) : set_scope.
Open Scope set_scope.

(** ** Subset relation *)

Definition subset (x : V) (y : V) : HProp
:= Build_HProp (forall z : V, z ∈ x -> z ∈ y).

Notation "x ⊆ y" := (subset x y) : set_scope.


(** ** Bisimulation relation *)
(** The equality in [V] lives in [Type@{U'}]. We define the bisimulation relation which is a [U]-small resizing of the equality in [V]: it must live in [HProp_U : Type{U'}], hence the codomain is [HProp@{U}]. We then prove that bisimulation is equality ([bisim_equals_id]), then use it to prove the key lemma [monic_set_present]. *)

(* We define [bisimulation] by double induction on [V]. We first fix the first argument as set(A,f) and define [bisim_aux : V -> HProp], by induction. This is the inner of the two inductions. *)
Local Definition bisim_aux (A : Type) (f : A -> V) (H_f : A -> V -> HProp) : V -> HProp.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
V -> HProp
Proof.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
V -> HProp
  apply V_rec' with
    (fun B g _ => Build_HProp ( (forall a, hexists (fun b => H_f a (g b)))
                               * forall b, hexists (fun a => H_f a (g b)) )
    ).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
IsHSet HProp
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
forall (A0 B : Type) (f : A0 -> V) (g : B -> V),
equal_img f g ->
forall (H_f0 : A0 -> HProp) (H_g : B -> HProp),
equal_img H_f0 H_g ->
Build_HProp
  ((forall a : A, hexists (fun b : A0 => H_f a (f b))) *
   (forall b : A0, hexists (fun a : A => H_f a (f b)))) =
Build_HProp
  ((forall a : A, hexists (fun b : B => H_f a (g b))) *
   (forall b : B, hexists (fun a : A => H_f a (g b))))
  -
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
IsHSet HProp exact _.
  -
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
forall (A0 B : Type) (f : A0 -> V) (g : B -> V),
equal_img f g ->
forall (H_f0 : A0 -> HProp) (H_g : B -> HProp),
equal_img H_f0 H_g ->
Build_HProp
  ((forall a : A, hexists (fun b : A0 => H_f a (f b))) *
   (forall b : A0, hexists (fun a : A => H_f a (f b)))) =
Build_HProp
  ((forall a : A, hexists (fun b : B => H_f a (g b))) *
   (forall b : B, hexists (fun a : A => H_f a (g b)))) intros B B' g g' eq_img H_g H_g' H_img; simpl.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
Build_HProp
  ((forall a : A, Tr (-1) {b : B & H_f a (g b)}) *
   (forall b : B, Tr (-1) {a : A & H_f a (g b)})) =
Build_HProp
  ((forall a : A, Tr (-1) {b : B' & H_f a (g' b)}) *
   (forall b : B', Tr (-1) {a : A & H_f a (g' b)}))
    apply path_iff_hprop; simpl.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
(forall a : A, Tr (-1) {b : B & H_f a (g b)}) *
(forall b : B, Tr (-1) {a : A & H_f a (g b)}) ->
(forall a : A, Tr (-1) {b : B' & H_f a (g' b)}) *
(forall b : B', Tr (-1) {a : A & H_f a (g' b)})
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
(forall a : A, Tr (-1) {b : B' & H_f a (g' b)}) *
(forall b : B', Tr (-1) {a : A & H_f a (g' b)}) ->
(forall a : A, Tr (-1) {b : B & H_f a (g b)}) *
(forall b : B, Tr (-1) {a : A & H_f a (g b)})
    +
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
(forall a : A, Tr (-1) {b : B & H_f a (g b)}) *
(forall b : B, Tr (-1) {a : A & H_f a (g b)}) ->
(forall a : A, Tr (-1) {b : B' & H_f a (g' b)}) *
(forall b : B', Tr (-1) {a : A & H_f a (g' b)}) intros [H1 H2]; split.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
forall b : B', Tr (-1) {a : A & H_f a (g' b)}
      *
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
forall a : A, Tr (-1) {b : B' & H_f a (g' b)} intro a.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
Tr (-1) {b : B' & H_f a (g' b)} refine (Trunc_rec _ (H1 a)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
{b : B & H_f a (g b)} ->
Tr (-1) {b : B' & H_f a (g' b)}
        intros [b H3].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
Tr (-1) {b : B' & H_f a (g' b)} generalize (fst eq_img b).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
hexists (fun b0 : B' => g b = g' b0) ->
Tr (-1) {b : B' & H_f a (g' b)}
        unfold hexists.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
merely {b0 : B' & g b = g' b0} ->
Tr (-1) {b : B' & H_f a (g' b)} refine (@Trunc_functor (-1) {b0 : B' & g b = g' b0} {b0 : B' & H_f a (g' b0)} _).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
{b0 : B' & g b = g' b0} -> {b0 : B' & H_f a (g' b0)}
        intros [b' p].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
b': B'
p: g b = g' b'
{b0 : B' & H_f a (g' b0)} exists b'.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
a: A
b: B
H3: H_f a (g b)
b': B'
p: g b = g' b'
H_f a (g' b') exact (transport (fun x => H_f a x) p H3).
      *
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
forall b : B', Tr (-1) {a : A & H_f a (g' b)} intro b'.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
Tr (-1) {a : A & H_f a (g' b')} refine (Trunc_rec _ (snd eq_img b')).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
{a : B & g a = g' b'} ->
Tr (-1) {a : A & H_f a (g' b')}
        intros [b p].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
b: B
p: g b = g' b'
Tr (-1) {a : A & H_f a (g' b')} generalize (H2 b).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
b: B
p: g b = g' b'
Tr (-1) {a : A & H_f a (g b)} ->
Tr (-1) {a : A & H_f a (g' b')} apply (Trunc_functor (-1)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
b: B
p: g b = g' b'
{a : A & H_f a (g b)} -> {a : A & H_f a (g' b')}
        intros [a H3].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
b: B
p: g b = g' b'
a: A
H3: H_f a (g b)
{a : A & H_f a (g' b')} exists a.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B & H_f a (g b)}
H2: forall b : B, Tr (-1) {a : A & H_f a (g b)}
b': B'
b: B
p: g b = g' b'
a: A
H3: H_f a (g b)
H_f a (g' b') exact (transport (fun x => H_f a x) p H3).
    +
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
(forall a : A, Tr (-1) {b : B' & H_f a (g' b)}) *
(forall b : B', Tr (-1) {a : A & H_f a (g' b)}) ->
(forall a : A, Tr (-1) {b : B & H_f a (g b)}) *
(forall b : B, Tr (-1) {a : A & H_f a (g b)}) intros [H1 H2]; split.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
forall a : A, Tr (-1) {b : B & H_f a (g b)}
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
forall b : B, Tr (-1) {a : A & H_f a (g b)}
      *
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
forall a : A, Tr (-1) {b : B & H_f a (g b)} intro a.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
Tr (-1) {b : B & H_f a (g b)} refine (Trunc_rec _ (H1 a)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
{b : B' & H_f a (g' b)} ->
Tr (-1) {b : B & H_f a (g b)}
        intros [b' H3].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
b': B'
H3: H_f a (g' b')
Tr (-1) {b : B & H_f a (g b)} generalize (snd eq_img b').
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
b': B'
H3: H_f a (g' b')
hexists (fun a : B => g a = g' b') ->
Tr (-1) {b : B & H_f a (g b)} apply (Trunc_functor (-1)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
b': B'
H3: H_f a (g' b')
{a : B & g a = g' b'} -> {b : B & H_f a (g b)}
        intros [b p].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
b': B'
H3: H_f a (g' b')
b: B
p: g b = g' b'
{b : B & H_f a (g b)} exists b.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
a: A
b': B'
H3: H_f a (g' b')
b: B
p: g b = g' b'
H_f a (g b) exact (transport (fun x => H_f a x) p^ H3).
      *
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
forall b : B, Tr (-1) {a : A & H_f a (g b)} intro b.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
Tr (-1) {a : A & H_f a (g b)} refine (Trunc_rec _ (fst eq_img b)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
{b0 : B' & g b = g' b0} ->
Tr (-1) {a : A & H_f a (g b)}
        intros [b' p].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
b': B'
p: g b = g' b'
Tr (-1) {a : A & H_f a (g b)} generalize (H2 b').
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
b': B'
p: g b = g' b'
Tr (-1) {a : A & H_f a (g' b')} ->
Tr (-1) {a : A & H_f a (g b)} apply (Trunc_functor (-1)).
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
b': B'
p: g b = g' b'
{a : A & H_f a (g' b')} -> {a : A & H_f a (g b)}
        intros [a H3].
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
b': B'
p: g b = g' b'
a: A
H3: H_f a (g' b')
{a : A & H_f a (g b)} exists a.
ua: Univalence
A: Type
f: A -> V
H_f: A -> V -> HProp
B, B': Type
g: B -> V
g': B' -> V
eq_img: equal_img g g'
H_g: B -> HProp
H_g': B' -> HProp
H_img: equal_img H_g H_g'
H1: forall a : A, Tr (-1) {b : B' & H_f a (g' b)}
H2: forall b : B', Tr (-1) {a : A & H_f a (g' b)}
b: B
b': B'
p: g b = g' b'
a: A
H3: H_f a (g' b')
H_f a (g b) exact (transport (fun x => H_f a x) p^ H3).
Defined.

(* Then we define [bisimulation : V -> (V -> HProp)] by induction again *)
Definition bisimulation : V@{U' U} -> V@{U' U} -> HProp@{U}.
ua: Univalence
V -> V -> HProp
Proof.
ua: Univalence
V -> V -> HProp
  refine (V_rec' (V -> HProp) _ bisim_aux _).
ua: Univalence
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> V -> HProp)
(H_g : B -> V -> HProp),
equal_img H_f H_g ->
bisim_aux A f H_f = bisim_aux B g H_g
  intros A B f g eq_img H_f H_g H_img.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
bisim_aux A f H_f = bisim_aux B g H_g
  apply path_forall.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
bisim_aux A f H_f == bisim_aux B g H_g
  refine (V_ind_hprop _ _ _).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
forall (A0 : Type) (f0 : A0 -> V),
(forall a : A0,
 bisim_aux A f H_f (f0 a) = bisim_aux B g H_g (f0 a)) ->
bisim_aux A f H_f (set f0) =
bisim_aux B g H_g (set f0)
  intros C h _; simpl.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
bisim_aux A f H_f (set h) = bisim_aux B g H_g (set h)
  apply path_iff_hprop; simpl.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
(forall a : A, Tr (-1) {b : C & H_f a (h b)}) *
(forall b : C, Tr (-1) {a : A & H_f a (h b)}) ->
(forall a : B, Tr (-1) {b : C & H_g a (h b)}) *
(forall b : C, Tr (-1) {a : B & H_g a (h b)})
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
(forall a : B, Tr (-1) {b : C & H_g a (h b)}) *
(forall b : C, Tr (-1) {a : B & H_g a (h b)}) ->
(forall a : A, Tr (-1) {b : C & H_f a (h b)}) *
(forall b : C, Tr (-1) {a : A & H_f a (h b)})
  -
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
(forall a : A, Tr (-1) {b : C & H_f a (h b)}) *
(forall b : C, Tr (-1) {a : A & H_f a (h b)}) ->
(forall a : B, Tr (-1) {b : C & H_g a (h b)}) *
(forall b : C, Tr (-1) {a : B & H_g a (h b)}) intros [H1 H2]; split.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
forall a : B, Tr (-1) {b : C & H_g a (h b)}
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
forall b : C, Tr (-1) {a : B & H_g a (h b)}
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
forall a : B, Tr (-1) {b : C & H_g a (h b)} intro b.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
Tr (-1) {b0 : C & H_g b (h b0)} refine (Trunc_rec _ (snd H_img b)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
{a : A & H_f a = H_g b} ->
Tr (-1) {b0 : C & H_g b (h b0)}
      intros [a p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
a: A
p: H_f a = H_g b
Tr (-1) {b0 : C & H_g b (h b0)} generalize (H1 a).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
a: A
p: H_f a = H_g b
Tr (-1) {b : C & H_f a (h b)} ->
Tr (-1) {b0 : C & H_g b (h b0)} apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
a: A
p: H_f a = H_g b
{b : C & H_f a (h b)} -> {b0 : C & H_g b (h b0)}
      intros [c H3].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
a: A
p: H_f a = H_g b
c: C
H3: H_f a (h c)
{b0 : C & H_g b (h b0)} exists c.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
b: B
a: A
p: H_f a = H_g b
c: C
H3: H_f a (h c)
H_g b (h c) exact ((ap10 p (h c)) # H3).
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
forall b : C, Tr (-1) {a : B & H_g a (h b)} intro c.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
Tr (-1) {a : B & H_g a (h c)} refine (Trunc_rec _ (H2 c)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
{a : A & H_f a (h c)} -> Tr (-1) {a : B & H_g a (h c)}
      intros [a H3].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
a: A
H3: H_f a (h c)
Tr (-1) {a : B & H_g a (h c)} generalize (fst H_img a).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
a: A
H3: H_f a (h c)
hexists (fun b : B => H_f a = H_g b) ->
Tr (-1) {a : B & H_g a (h c)} apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
a: A
H3: H_f a (h c)
{b : B & H_f a = H_g b} -> {a : B & H_g a (h c)}
      intros [b p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
a: A
H3: H_f a (h c)
b: B
p: H_f a = H_g b
{a : B & H_g a (h c)} exists b.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : A, Tr (-1) {b : C & H_f a (h b)}
H2: forall b : C, Tr (-1) {a : A & H_f a (h b)}
c: C
a: A
H3: H_f a (h c)
b: B
p: H_f a = H_g b
H_g b (h c) exact ((ap10 p (h c)) # H3).
  -
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
(forall a : B, Tr (-1) {b : C & H_g a (h b)}) *
(forall b : C, Tr (-1) {a : B & H_g a (h b)}) ->
(forall a : A, Tr (-1) {b : C & H_f a (h b)}) *
(forall b : C, Tr (-1) {a : A & H_f a (h b)}) intros [H1 H2]; split.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
forall a : A, Tr (-1) {b : C & H_f a (h b)}
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
forall b : C, Tr (-1) {a : A & H_f a (h b)}
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
forall a : A, Tr (-1) {b : C & H_f a (h b)} intro a.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
Tr (-1) {b : C & H_f a (h b)} refine (Trunc_rec _ (fst H_img a)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
{b : B & H_f a = H_g b} ->
Tr (-1) {b : C & H_f a (h b)}
      intros [b p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
b: B
p: H_f a = H_g b
Tr (-1) {b : C & H_f a (h b)} generalize (H1 b).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
b: B
p: H_f a = H_g b
Tr (-1) {b0 : C & H_g b (h b0)} ->
Tr (-1) {b : C & H_f a (h b)} apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
b: B
p: H_f a = H_g b
{b0 : C & H_g b (h b0)} -> {b : C & H_f a (h b)}
      intros [c H3].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
b: B
p: H_f a = H_g b
c: C
H3: H_g b (h c)
{b : C & H_f a (h b)} exists c.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
a: A
b: B
p: H_f a = H_g b
c: C
H3: H_g b (h c)
H_f a (h c) exact ((ap10 p^ (h c)) # H3).
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
forall b : C, Tr (-1) {a : A & H_f a (h b)} intro c.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
Tr (-1) {a : A & H_f a (h c)} refine (Trunc_rec _ (H2 c)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
{a : B & H_g a (h c)} -> Tr (-1) {a : A & H_f a (h c)}
      intros [b H3].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
b: B
H3: H_g b (h c)
Tr (-1) {a : A & H_f a (h c)} generalize (snd H_img b).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
b: B
H3: H_g b (h c)
hexists (fun a : A => H_f a = H_g b) ->
Tr (-1) {a : A & H_f a (h c)} apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
b: B
H3: H_g b (h c)
{a : A & H_f a = H_g b} -> {a : A & H_f a (h c)}
      intros [a p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
b: B
H3: H_g b (h c)
a: A
p: H_f a = H_g b
{a : A & H_f a (h c)} exists a.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
H_f: A -> V -> HProp
H_g: B -> V -> HProp
H_img: equal_img H_f H_g
C: Type
h: C -> V
H1: forall a : B, Tr (-1) {b : C & H_g a (h b)}
H2: forall b : C, Tr (-1) {a : B & H_g a (h b)}
c: C
b: B
H3: H_g b (h c)
a: A
p: H_f a = H_g b
H_f a (h c) exact ((ap10 p^ (h c)) # H3).
Defined.

Notation "u ~~ v" := (bisimulation u v) : set_scope.

#[export] Instance reflexive_bisimulation : Reflexive bisimulation.
ua: Univalence
Reflexive (fun x x0 : V => x ~~ x0)
Proof.
ua: Univalence
Reflexive (fun x x0 : V => x ~~ x0)
  refine (V_ind_hprop _ _ _).
ua: Univalence
forall (A : Type) (f : A -> V),
(forall a : A, f a ~~ f a) -> set f ~~ set f
  intros A f H_f.
ua: Univalence
A: Type
f: A -> V
H_f: forall a : A, f a ~~ f a
set f ~~ set f split.
ua: Univalence
A: Type
f: A -> V
H_f: forall a : A, f a ~~ f a
forall a : A,
hexists
  (fun b : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0) (h0 b0)})
               =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0) (h0 b0)})
               =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (f b))
ua: Univalence
A: Type
f: A -> V
H_f: forall a : A, f a ~~ f a
forall b : A,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0) (h0 b0)})
               =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0) (h0 b0)})
               =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (f b))
  -
ua: Univalence
A: Type
f: A -> V
H_f: forall a : A, f a ~~ f a
forall a : A,
hexists
  (fun b : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0) (h0 b0)})
               =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0) (h0 b0)})
               =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (f b)) intro a; apply tr; exists a; auto.
  -
ua: Univalence
A: Type
f: A -> V
H_f: forall a : A, f a ~~ f a
forall b : A,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0) (h0 b0)})
               =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0) (h0 b0)})
               =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (f b)) intro a; apply tr; exists a; auto.
Defined.

Lemma bisimulation_equiv_id : forall u v : V, (u = v) <~> (u ~~ v).
ua: Univalence
forall u v : V, u = v <~> u ~~ v
Proof.
ua: Univalence
forall u v : V, u = v <~> u ~~ v
  intros u v.
ua: Univalence
u, v: V
u = v <~> u ~~ v
  apply equiv_iff_hprop.
ua: Univalence
u, v: V
u = v -> u ~~ v
ua: Univalence
u, v: V
u ~~ v -> u = v
  -
ua: Univalence
u, v: V
u = v -> u ~~ v intro p; exact (transport (fun x => u ~~ x) p (reflexive_bisimulation u)).
  -
ua: Univalence
u, v: V
u ~~ v -> u = v generalize u v.
ua: Univalence
u, v: V
forall u v : V, u ~~ v -> u = v
    refine (V_ind_hprop _ _ _); intros A f H_f.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
forall v : V, set f ~~ v -> set f = v
    refine (V_ind_hprop _ _ _); intros B g _.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
set f ~~ set g -> set f = set g
    intros [H1 H2].
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
set f = set g
    apply setext'.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
equal_img f g split.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
forall a : A, hexists (fun b : B => f a = g b)
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
forall b : B, hexists (fun a : A => f a = g b)
    +
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
forall a : A, hexists (fun b : B => f a = g b) intro a.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
a: A
hexists (fun b : B => f a = g b) generalize (H1 a).
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
a: A
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a)) =>
            path_iff_hprop
              (fun
                 X : (forall a : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a : A &
                        H_h (spushl (...) a) (h0 b0)})
               =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a : A &
                         H_h (spushl ... a) (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a) (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a : B &
                        H_h (spushr (...) a) (h0 b0)})
               =>
               (fun a : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a : B &
                         H_h (spushr ... a) (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (g b)) ->
hexists (fun b : B => f a = g b) apply (Trunc_functor (-1)).
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
a: A
{b : B &
V_ind (fun _ : V => V -> HProp)
  (fun _ : V => istrunc_arrow) bisim_aux
  (fun (A B : Type) (R : A -> B -> HProp)
     (bitot_R : bitotal R)
     (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
          V)
     (H_h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
            V -> HProp) =>
   transport_const (setext R bitot_R h)
     (bisim_aux A
        (fun x : A =>
         h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : A =>
         H_h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))) @
   path_forall
     (bisim_aux A
        (fun x : A =>
         h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : A =>
         H_h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x)))
     (bisim_aux B
        (fun x : B =>
         h
           (spushr (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : B =>
         H_h
           (spushr (fun (x0 : A) (x1 : B) => R x0 x1)
              x)))
     (V_ind_hprop
        (fun v : V =>
         bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           v =
         bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           v)
        (fun (C : Type) (h0 : C -> V)
           (_ : forall a : C,
                bisim_aux A
                  (fun x : A =>
                   h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : A =>
                   H_h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a) =
                bisim_aux B
                  (fun x : B =>
                   h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : B =>
                   H_h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a)) =>
         path_iff_hprop
           (fun
              X : (forall a : A,
                   Tr (-1)
                     {b0 : C &
                     H_h
                       (spushl (fun ... ... => R x x0)
                          a) (h0 b0)}) *
                  (forall b0 : C,
                   Tr (-1)
                     {a : A &
                     H_h
                       (spushl (fun ... ... => R x x0)
                          a) (h0 b0)}) =>
            (fun b0 : B =>
             Trunc_rec
               (fun
                  X0 : {a : A &
                       H_h (spushl (...) a) =
                       H_h (spushr (...) b0)} =>
                Trunc_functor (-1)
                  (fun X1 : {b1 : C & H_h (...) (...)}
                   =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 X0.2 (...)) X1.2))
                  (fst X X0.1))
               (snd
                  (fun a : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b1 : B & ...} =>
                      (X0.1; ap H_h (...)))
                     (fst bitot_R a),
                  fun b1 : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a : A & ...} =>
                     (X0.1; ap H_h (...)))
                    (snd bitot_R b1)) b0),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : A &
                      H_h (spushl (... => ...) a)
                        (h0 c)} =>
               Trunc_functor (-1)
                 (fun
                    X1 : {b0 : B & H_h ... = H_h ...}
                  =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 X1.2 (...)) X0.2))
                 (fst
                    (fun a : A =>
                     Trunc_functor (-1) (... => ...)
                       (fst bitot_R a),
                    fun b0 : B =>
                    Trunc_functor (-1) (... => ...)
                      (snd bitot_R b0)) X0.1))
              (snd X c)))
           (fun
              X : (forall a : B,
                   Tr (-1)
                     {b0 : C &
                     H_h
                       (spushr (fun ... ... => R x x0)
                          a) (h0 b0)}) *
                  (forall b0 : C,
                   Tr (-1)
                     {a : B &
                     H_h
                       (spushr (fun ... ... => R x x0)
                          a) (h0 b0)}) =>
            (fun a : A =>
             Trunc_rec
               (fun
                  X0 : {b0 : B &
                       H_h (spushl (...) a) =
                       H_h (spushr (...) b0)} =>
                Trunc_functor (-1)
                  (fun X1 : {b0 : C & H_h (...) (...)}
                   =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 (X0.2)^ (...)) X1.2))
                  (fst X X0.1))
               (fst
                  (fun a0 : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b0 : B & ...} =>
                      (X0.1; ap H_h (...)))
                     (fst bitot_R a0),
                  fun b0 : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a0 : A & ...} =>
                     (X0.1; ap H_h (...)))
                    (snd bitot_R b0)) a),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : B &
                      H_h (spushr (... => ...) a)
                        (h0 c)} =>
               Trunc_functor (-1)
                 (fun X1 : {a : A & H_h ... = H_h ...}
                  =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 (X1.2)^ (...)) X0.2))
                 (snd
                    (fun a : A =>
                     Trunc_functor (-1) (... => ...)
                       (fst bitot_R a),
                    fun b0 : B =>
                    Trunc_functor (-1) (... => ...)
                      (snd bitot_R b0)) X0.1))
              (snd X c))))
        (fun v : V =>
         istrunc_paths HProp (-1)
           (bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)))) (f a) (g b)} ->
{b : B & f a = g b}
      intros [b h].
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
a: A
b: B
h: V_ind (fun _ : V => V -> HProp)
  (fun _ : V => istrunc_arrow) bisim_aux
  (fun (A B : Type) (R : A -> B -> HProp)
     (bitot_R : bitotal R)
     (h : SPushout
            (fun (x : A) (x0 : B) => R x x0) -> V)
     (H_h : SPushout
              (fun (x : A) (x0 : B) => R x x0) ->
            V -> HProp) =>
   transport_const (setext R bitot_R h)
     (bisim_aux A
        (fun x : A =>
         h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : A =>
         H_h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
   path_forall
     (bisim_aux A
        (fun x : A =>
         h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : A =>
         H_h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x)))
     (bisim_aux B
        (fun x : B =>
         h
           (spushr
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : B =>
         H_h
           (spushr
              (fun (x0 : A) (x1 : B) => R x0 x1) x)))
     (V_ind_hprop
        (fun v : V =>
         bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x)) v =
         bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x)) v)
        (fun (C : Type) (h0 : C -> V)
           (_ : forall a : C,
                bisim_aux A
                  (fun x : A =>
                   h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : A =>
                   H_h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a) =
                bisim_aux B
                  (fun x : B =>
                   h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : B =>
                   H_h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a)) =>
         path_iff_hprop
           (fun
              X : (forall a : A,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushl
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a : A &
                     H_h
                       (spushl
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) =>
            (fun b : B =>
             Trunc_rec
               (fun
                  X0 : {a : A &
                       H_h
                         (spushl
                            (fun ... ... => R x x0)
                            a) =
                       H_h
                         (spushr
                            (fun ... ... => R x x0)
                            b)} =>
                Trunc_functor (-1)
                  (fun
                     X1 : {b0 : C &
                          H_h (spushl (...) X0.1)
                            (h0 b0)} =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 X0.2 (h0 X1.1)) X1.2))
                  (fst X X0.1))
               (snd
                  (fun a : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b0 : B & R a b0}
                      =>
                      (X0.1;
                      ap H_h (spglue (...) X0.2)))
                     (fst bitot_R a),
                  fun b0 : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a : A & R a b0} =>
                     (X0.1;
                     ap H_h (spglue (...) X0.2)))
                    (snd bitot_R b0)) b),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : A &
                      H_h
                        (spushl
                           (fun (x : A) (x0 : B)
                            => R x x0) a) (h0 c)}
               =>
               Trunc_functor (-1)
                 (fun
                    X1 : {b : B &
                         H_h (spushl ... X0.1) =
                         H_h (spushr ... b)} =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 X1.2 (h0 c)) X0.2))
                 (fst
                    (fun a : A =>
                     Trunc_functor (-1)
                       (fun X1 : ... =>
                        (X1.1; ap H_h ...))
                       (fst bitot_R a),
                    fun b : B =>
                    Trunc_functor (-1)
                      (fun X1 : ... =>
                       (X1.1; ap H_h ...))
                      (snd bitot_R b)) X0.1))
              (snd X c)))
           (fun
              X : (forall a : B,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushr
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a : B &
                     H_h
                       (spushr
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) =>
            (fun a : A =>
             Trunc_rec
               (fun
                  X0 : {b : B &
                       H_h
                         (spushl
                            (fun ... ... => R x x0)
                            a) =
                       H_h
                         (spushr
                            (fun ... ... => R x x0)
                            b)} =>
                Trunc_functor (-1)
                  (fun
                     X1 : {b : C &
                          H_h (spushr (...) X0.1)
                            (h0 b)} =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 (X0.2)^ (h0 X1.1)) X1.2))
                  (fst X X0.1))
               (fst
                  (fun a0 : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b : B & R a0 b} =>
                      (X0.1;
                      ap H_h (spglue (...) X0.2)))
                     (fst bitot_R a0),
                  fun b : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a0 : A & R a0 b} =>
                     (X0.1;
                     ap H_h (spglue (...) X0.2)))
                    (snd bitot_R b)) a),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : B &
                      H_h
                        (spushr
                           (fun (x : A) (x0 : B)
                            => R x x0) a) (h0 c)}
               =>
               Trunc_functor (-1)
                 (fun
                    X1 : {a : A &
                         H_h (spushl ... a) =
                         H_h (spushr ... X0.1)} =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 (X1.2)^ (h0 c)) X0.2))
                 (snd
                    (fun a : A =>
                     Trunc_functor (-1)
                       (fun X1 : ... =>
                        (X1.1; ap H_h ...))
                       (fst bitot_R a),
                    fun b : B =>
                    Trunc_functor (-1)
                      (fun X1 : ... =>
                       (X1.1; ap H_h ...))
                      (snd bitot_R b)) X0.1))
              (snd X c))))
        (fun v : V =>
         istrunc_paths HProp (-1)
           (bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)))) (f a)
  (g b)
{b : B & f a = g b} exists b; exact (H_f a (g b) h).
    +
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
forall b : B, hexists (fun a : A => f a = g b) intro b.
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
b: B
hexists (fun a : A => f a = g b) generalize (H2 b).
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
b: B
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B) =>
                            R x0 x1) x)) (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b : C &
                        H_h (spushl (...) a0) (h0 b)}) *
                     (forall b : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0) (h0 b)})
               =>
               (fun b : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) b),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {b : B & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b : C &
                        H_h (spushr (...) a0) (h0 b)}) *
                     (forall b : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0) (h0 b)})
               =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b : B &
                          H_h (...) = H_h (...)} =>
                   Trunc_functor (-1)
                     (fun X1 : {b : C & ...} =>
                      (X1.1;
                      transport trunctype_type (...)
                        X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0) (h0 c)}
                  =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type (...)
                       X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...) X0.1))
                 (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a) (g b)) ->
hexists (fun a : A => f a = g b) apply (Trunc_functor (-1)).
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
b: B
{a : A &
V_ind (fun _ : V => V -> HProp)
  (fun _ : V => istrunc_arrow) bisim_aux
  (fun (A B : Type) (R : A -> B -> HProp)
     (bitot_R : bitotal R)
     (h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
          V)
     (H_h : SPushout (fun (x : A) (x0 : B) => R x x0) ->
            V -> HProp) =>
   transport_const (setext R bitot_R h)
     (bisim_aux A
        (fun x : A =>
         h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : A =>
         H_h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))) @
   path_forall
     (bisim_aux A
        (fun x : A =>
         h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : A =>
         H_h
           (spushl (fun (x0 : A) (x1 : B) => R x0 x1)
              x)))
     (bisim_aux B
        (fun x : B =>
         h
           (spushr (fun (x0 : A) (x1 : B) => R x0 x1)
              x))
        (fun x : B =>
         H_h
           (spushr (fun (x0 : A) (x1 : B) => R x0 x1)
              x)))
     (V_ind_hprop
        (fun v : V =>
         bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           v =
         bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1) x))
           v)
        (fun (C : Type) (h0 : C -> V)
           (_ : forall a0 : C,
                bisim_aux A
                  (fun x : A =>
                   h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : A =>
                   H_h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a0) =
                bisim_aux B
                  (fun x : B =>
                   h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : B =>
                   H_h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a0)) =>
         path_iff_hprop
           (fun
              X : (forall a0 : A,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushl (fun ... ... => R x x0)
                          a0) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a0 : A &
                     H_h
                       (spushl (fun ... ... => R x x0)
                          a0) (h0 b)}) =>
            (fun b : B =>
             Trunc_rec
               (fun
                  X0 : {a0 : A &
                       H_h (spushl (...) a0) =
                       H_h (spushr (...) b)} =>
                Trunc_functor (-1)
                  (fun X1 : {b0 : C & H_h (...) (...)}
                   =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 X0.2 (...)) X1.2))
                  (fst X X0.1))
               (snd
                  (fun a0 : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b0 : B & ...} =>
                      (X0.1; ap H_h (...)))
                     (fst bitot_R a0),
                  fun b0 : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a0 : A & ...} =>
                     (X0.1; ap H_h (...)))
                    (snd bitot_R b0)) b),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a0 : A &
                      H_h (spushl (... => ...) a0)
                        (h0 c)} =>
               Trunc_functor (-1)
                 (fun X1 : {b : B & H_h ... = H_h ...}
                  =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 X1.2 (...)) X0.2))
                 (fst
                    (fun a0 : A =>
                     Trunc_functor (-1) (... => ...)
                       (fst bitot_R a0),
                    fun b : B =>
                    Trunc_functor (-1) (... => ...)
                      (snd bitot_R b)) X0.1))
              (snd X c)))
           (fun
              X : (forall a0 : B,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushr (fun ... ... => R x x0)
                          a0) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a0 : B &
                     H_h
                       (spushr (fun ... ... => R x x0)
                          a0) (h0 b)}) =>
            (fun a0 : A =>
             Trunc_rec
               (fun
                  X0 : {b : B &
                       H_h (spushl (...) a0) =
                       H_h (spushr (...) b)} =>
                Trunc_functor (-1)
                  (fun X1 : {b : C & H_h (...) (...)}
                   =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 (X0.2)^ (...)) X1.2))
                  (fst X X0.1))
               (fst
                  (fun a1 : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b : B & ...} =>
                      (X0.1; ap H_h (...)))
                     (fst bitot_R a1),
                  fun b : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a1 : A & ...} =>
                     (X0.1; ap H_h (...)))
                    (snd bitot_R b)) a0),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a0 : B &
                      H_h (spushr (... => ...) a0)
                        (h0 c)} =>
               Trunc_functor (-1)
                 (fun
                    X1 : {a0 : A & H_h ... = H_h ...}
                  =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 (X1.2)^ (...)) X0.2))
                 (snd
                    (fun a0 : A =>
                     Trunc_functor (-1) (... => ...)
                       (fst bitot_R a0),
                    fun b : B =>
                    Trunc_functor (-1) (... => ...)
                      (snd bitot_R b)) X0.1))
              (snd X c))))
        (fun v : V =>
         istrunc_paths HProp (-1)
           (bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)
           (bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) => R x0 x1)
                    x)) v)))) (f a) (g b)} ->
{a : A & f a = g b}
      intros [a h].
ua: Univalence
u, v: V
A: Type
f: A -> V
H_f: forall (a : A) (v : V), f a ~~ v -> f a = v
B: Type
g: B -> V
H1: forall a : A,
hexists
  (fun b : B =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
H2: forall b : B,
hexists
  (fun a : A =>
   V_ind (fun _ : V => V -> HProp)
     (fun _ : V => istrunc_arrow) bisim_aux
     (fun (A B : Type) (R : A -> B -> HProp)
        (bitot_R : bitotal R)
        (h : SPushout
               (fun (x : A) (x0 : B) => R x x0) ->
             V)
        (H_h : SPushout
                 (fun (x : A) (x0 : B) => R x x0) ->
               V -> HProp) =>
      transport_const (setext R bitot_R h)
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))) @
      path_forall
        (bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) =>
                  R x0 x1) x)))
        (V_ind_hprop
           (fun v : V =>
            bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v =
            bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (fun (C : Type) (h0 : C -> V)
              (_ : forall a0 : C,
                   bisim_aux A
                     (fun x : A =>
                      h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : A =>
                      H_h
                        (spushl
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0) =
                   bisim_aux B
                     (fun x : B =>
                      h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (fun x : B =>
                      H_h
                        (spushr
                           (fun (x0 : A) (x1 : B)
                            => R x0 x1) x))
                     (h0 a0)) =>
            path_iff_hprop
              (fun
                 X : (forall a0 : A,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushl (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : A &
                        H_h (spushl (...) a0)
                          (h0 b0)}) =>
               (fun b0 : B =>
                Trunc_rec
                  (fun
                     X0 : {a0 : A &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b1 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (snd
                     (fun a0 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a0),
                     fun b1 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b1)) b0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : A &
                         H_h (spushl ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {b0 : B & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (fst
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c)))
              (fun
                 X : (forall a0 : B,
                      Tr (-1)
                        {b0 : C &
                        H_h (spushr (...) a0)
                          (h0 b0)}) *
                     (forall b0 : C,
                      Tr (-1)
                        {a0 : B &
                        H_h (spushr (...) a0)
                          (h0 b0)}) =>
               (fun a0 : A =>
                Trunc_rec
                  (fun
                     X0 : {b0 : B &
                          H_h (...) = H_h (...)}
                   =>
                   Trunc_functor (-1)
                     (fun X1 : {b0 : C & ...} =>
                      (X1.1;
                      transport trunctype_type
                        (...) X1.2)) (fst X X0.1))
                  (fst
                     (fun a1 : A =>
                      Trunc_functor (-1)
                        (fun ... => (X0.1; ...))
                        (fst bitot_R a1),
                     fun b0 : B =>
                     Trunc_functor (-1)
                       (fun ... => (X0.1; ...))
                       (snd bitot_R b0)) a0),
               fun c : C =>
               Trunc_rec
                 (fun
                    X0 : {a0 : B &
                         H_h (spushr ... a0)
                           (h0 c)} =>
                  Trunc_functor (-1)
                    (fun X1 : {a0 : A & ...} =>
                     (X1.1;
                     transport trunctype_type
                       (...) X0.2))
                    (snd
                       (fun ... =>
                        Trunc_functor ... ... ...,
                       fun ... =>
                       Trunc_functor ... ... ...)
                       X0.1)) (snd X c))))
           (fun v : V =>
            istrunc_paths HProp (-1)
              (bisim_aux A
                 (fun x : A =>
                  h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : A =>
                  H_h
                    (spushl
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)
              (bisim_aux B
                 (fun x : B =>
                  h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x))
                 (fun x : B =>
                  H_h
                    (spushr
                       (fun (x0 : A) (x1 : B) =>
                        R x0 x1) x)) v)))) (f a)
     (g b))
b: B
a: A
h: V_ind (fun _ : V => V -> HProp)
  (fun _ : V => istrunc_arrow) bisim_aux
  (fun (A B : Type) (R : A -> B -> HProp)
     (bitot_R : bitotal R)
     (h : SPushout
            (fun (x : A) (x0 : B) => R x x0) -> V)
     (H_h : SPushout
              (fun (x : A) (x0 : B) => R x x0) ->
            V -> HProp) =>
   transport_const (setext R bitot_R h)
     (bisim_aux A
        (fun x : A =>
         h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : A =>
         H_h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))) @
   path_forall
     (bisim_aux A
        (fun x : A =>
         h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : A =>
         H_h
           (spushl
              (fun (x0 : A) (x1 : B) => R x0 x1) x)))
     (bisim_aux B
        (fun x : B =>
         h
           (spushr
              (fun (x0 : A) (x1 : B) => R x0 x1) x))
        (fun x : B =>
         H_h
           (spushr
              (fun (x0 : A) (x1 : B) => R x0 x1) x)))
     (V_ind_hprop
        (fun v : V =>
         bisim_aux A
           (fun x : A =>
            h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x))
           (fun x : A =>
            H_h
              (spushl
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x)) v =
         bisim_aux B
           (fun x : B =>
            h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x))
           (fun x : B =>
            H_h
              (spushr
                 (fun (x0 : A) (x1 : B) => R x0 x1)
                 x)) v)
        (fun (C : Type) (h0 : C -> V)
           (_ : forall a : C,
                bisim_aux A
                  (fun x : A =>
                   h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : A =>
                   H_h
                     (spushl
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a) =
                bisim_aux B
                  (fun x : B =>
                   h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x))
                  (fun x : B =>
                   H_h
                     (spushr
                        (fun (x0 : A) (x1 : B) =>
                         R x0 x1) x)) (h0 a)) =>
         path_iff_hprop
           (fun
              X : (forall a : A,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushl
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a : A &
                     H_h
                       (spushl
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) =>
            (fun b : B =>
             Trunc_rec
               (fun
                  X0 : {a : A &
                       H_h
                         (spushl
                            (fun ... ... => R x x0)
                            a) =
                       H_h
                         (spushr
                            (fun ... ... => R x x0)
                            b)} =>
                Trunc_functor (-1)
                  (fun
                     X1 : {b0 : C &
                          H_h (spushl (...) X0.1)
                            (h0 b0)} =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 X0.2 (h0 X1.1)) X1.2))
                  (fst X X0.1))
               (snd
                  (fun a : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b0 : B & R a b0}
                      =>
                      (X0.1;
                      ap H_h (spglue (...) X0.2)))
                     (fst bitot_R a),
                  fun b0 : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a : A & R a b0} =>
                     (X0.1;
                     ap H_h (spglue (...) X0.2)))
                    (snd bitot_R b0)) b),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : A &
                      H_h
                        (spushl
                           (fun (x : A) (x0 : B)
                            => R x x0) a) (h0 c)}
               =>
               Trunc_functor (-1)
                 (fun
                    X1 : {b : B &
                         H_h (spushl ... X0.1) =
                         H_h (spushr ... b)} =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 X1.2 (h0 c)) X0.2))
                 (fst
                    (fun a : A =>
                     Trunc_functor (-1)
                       (fun X1 : ... =>
                        (X1.1; ap H_h ...))
                       (fst bitot_R a),
                    fun b : B =>
                    Trunc_functor (-1)
                      (fun X1 : ... =>
                       (X1.1; ap H_h ...))
                      (snd bitot_R b)) X0.1))
              (snd X c)))
           (fun
              X : (forall a : B,
                   Tr (-1)
                     {b : C &
                     H_h
                       (spushr
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) *
                  (forall b : C,
                   Tr (-1)
                     {a : B &
                     H_h
                       (spushr
                          (fun (x : A) (x0 : B) =>
                           R x x0) a) (h0 b)}) =>
            (fun a : A =>
             Trunc_rec
               (fun
                  X0 : {b : B &
                       H_h
                         (spushl
                            (fun ... ... => R x x0)
                            a) =
                       H_h
                         (spushr
                            (fun ... ... => R x x0)
                            b)} =>
                Trunc_functor (-1)
                  (fun
                     X1 : {b : C &
                          H_h (spushr (...) X0.1)
                            (h0 b)} =>
                   (X1.1;
                   transport trunctype_type
                     (ap10 (X0.2)^ (h0 X1.1)) X1.2))
                  (fst X X0.1))
               (fst
                  (fun a0 : A =>
                   Trunc_functor (-1)
                     (fun X0 : {b : B & R a0 b} =>
                      (X0.1;
                      ap H_h (spglue (...) X0.2)))
                     (fst bitot_R a0),
                  fun b : B =>
                  Trunc_functor (-1)
                    (fun X0 : {a0 : A & R a0 b} =>
                     (X0.1;
                     ap H_h (spglue (...) X0.2)))
                    (snd bitot_R b)) a),
            fun c : C =>
            Trunc_rec
              (fun
                 X0 : {a : B &
                      H_h
                        (spushr
                           (fun (x : A) (x0 : B)
                            => R x x0) a) (h0 c)}
               =>
               Trunc_functor (-1)
                 (fun
                    X1 : {a : A &
                         H_h (spushl ... a) =
                         H_h (spushr ... X0.1)} =>
                  (X1.1;
                  transport trunctype_type
                    (ap10 (X1.2)^ (h0 c)) X0.2))
                 (snd
                    (fun a : A =>
                     Trunc_functor (-1)
                       (fun X1 : ... =>
                        (X1.1; ap H_h ...))
                       (fst bitot_R a),
                    fun b : B =>
                    Trunc_functor (-1)
                      (fun X1 : ... =>
                       (X1.1; ap H_h ...))
                      (snd bitot_R b)) X0.1))
              (snd X c))))
        (fun v : V =>
         istrunc_paths HProp (-1)
           (bisim_aux A
              (fun x : A =>
               h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : A =>
               H_h
                 (spushl
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)
           (bisim_aux B
              (fun x : B =>
               h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x))
              (fun x : B =>
               H_h
                 (spushr
                    (fun (x0 : A) (x1 : B) =>
                     R x0 x1) x)) v)))) (f a)
  (g b)
{a : A & f a = g b} exists a; exact (H_f a (g b) h).
Defined.


(** ** Canonical presentation of V-sets (Lemma 10.5.6) *)

(** Using the regular kernel would lead to a universe inconsistency in the [monic_set_present] lemma later. *)
Definition ker_bisim {A} (f : A -> V) (x y : A) := (f x ~~ f y).

Definition ker_bisim_is_ker {A} (f : A -> V)
  : forall (x y : A), f x = f y <~> ker_bisim f x y.
ua: Univalence
A: Type
f: A -> V
forall x y : A, f x = f y <~> ker_bisim f x y
Proof.
ua: Univalence
A: Type
f: A -> V
forall x y : A, f x = f y <~> ker_bisim f x y
  intros; apply bisimulation_equiv_id.
Defined.

Section MonicSetPresent_Uniqueness.
(** Given [u : V], we want to show that the representation [u = @set Au mu], where [Au] is an hSet and [mu] is monic, is unique. *)

Context {u : V} {Au Au': Type} {h : IsHSet Au} {h' : IsHSet Au'} {mu : Au -> V} {mono : IsEmbedding mu}
  {mu' : Au' -> V} {mono' : IsEmbedding mu'} {p : u = set mu} {p' : u = set mu'}.

Lemma eq_img_untrunc : (forall a : Au, {a' : Au' & mu' a' = mu a})
                     * (forall a' : Au', {a : Au & mu a = mu' a'}).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
(forall a : Au, {a' : Au' & mu' a' = mu a}) *
(forall a' : Au', {a : Au & mu a = mu' a'})
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
(forall a : Au, {a' : Au' & mu' a' = mu a}) *
(forall a' : Au', {a : Au & mu a = mu' a'})
  split.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
forall a : Au, {a' : Au' & mu' a' = mu a}
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
forall a' : Au', {a : Au & mu a = mu' a'}
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
forall a : Au, {a' : Au' & mu' a' = mu a} intro a.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
a: Au
{a' : Au' & mu' a' = mu a} exact (@untrunc_istrunc (-1) _ (mono' (mu a)) (transport (fun x => mu a ∈ x) (p^ @ p') (tr (a; 1)))).
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
forall a' : Au', {a : Au & mu a = mu' a'} intro a'.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
a': Au'
{a : Au & mu a = mu' a'} exact (@untrunc_istrunc (-1) _ (mono (mu' a')) (transport (fun x => mu' a' ∈ x) (p'^ @ p) (tr (a'; 1)))).
Defined.

Let e : Au -> Au' := fun a => pr1 (fst eq_img_untrunc a).
Let inv_e : Au' -> Au := fun a' => pr1 (snd eq_img_untrunc a').

Let hom1 : e o inv_e == idmap.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
e o inv_e == idmap
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
e o inv_e == idmap
  intro a'.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
e (inv_e a') = a'
  apply (isinj_embedding mu' mono').
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
mu' (e (inv_e a')) = mu' a'
  transitivity (mu (inv_e a')).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
mu' (e (inv_e a')) = mu (inv_e a')
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
mu (inv_e a') = mu' a'
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
mu' (e (inv_e a')) = mu (inv_e a') exact (pr2 (fst eq_img_untrunc (inv_e a'))).
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
a': Au'
mu (inv_e a') = mu' a' exact (pr2 (snd eq_img_untrunc a')).
Defined.

Let hom2 : inv_e o e == idmap.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
inv_e o e == idmap
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
inv_e o e == idmap
  intro a.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
inv_e (e a) = a
  apply (isinj_embedding mu mono).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
mu (inv_e (e a)) = mu a
  transitivity (mu' (e a)).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
mu (inv_e (e a)) = mu' (e a)
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
mu' (e a) = mu a
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
mu (inv_e (e a)) = mu' (e a) exact (pr2 (snd eq_img_untrunc (e a))).
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
a: Au
mu' (e a) = mu a exact (pr2 (fst eq_img_untrunc a)).
Defined.

Let path : Au' = Au.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
Au' = Au
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
Au' = Au
  apply path_universe_uncurried.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
Au' <~> Au
  exact (equiv_adjointify inv_e e hom2 hom1).
Defined.

Lemma mu_eq_mu' : transport (fun A : Type => A -> V) path^ mu = mu'.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport (fun A : Type => A -> V) path^ mu = mu'
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport (fun A : Type => A -> V) path^ mu = mu'
  apply path_forall.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport (fun A : Type => A -> V) path^ mu == mu' intro a'.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun A : Type => A -> V) path^ mu a' =
mu' a'
  transitivity (transport (fun X => V) path^ (mu (transport (fun X : Type => X) path^^ a'))).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun A : Type => A -> V) path^ mu a' =
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a'))
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a')) = 
mu' a'
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun A : Type => A -> V) path^ mu a' =
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a')) exact (@transport_arrow Type (fun X : Type => X) (fun X => V) Au Au' path^ mu a').
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a')) = mu' a' transitivity (mu (transport idmap path^^ a')).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a')) =
mu (transport idmap (path^)^ a')
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
mu (transport idmap (path^)^ a') = mu' a'
    +
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport (fun _ : Type => V) path^
  (mu (transport idmap (path^)^ a')) =
mu (transport idmap (path^)^ a') apply transport_const.
    +
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
mu (transport idmap (path^)^ a') = mu' a' transitivity (mu (inv_e a')).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
mu (transport idmap (path^)^ a') = mu (inv_e a')
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
mu (inv_e a') = mu' a'
      2: exact (pr2 (snd eq_img_untrunc a')).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
mu (transport idmap (path^)^ a') = mu (inv_e a')
      refine (ap mu _).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport idmap (path^)^ a' = inv_e a'
      transitivity (transport idmap path a').
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport idmap (path^)^ a' = transport idmap path a'
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport idmap path a' = inv_e a'
      *
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport idmap (path^)^ a' = transport idmap path a' exact (ap (fun x => transport idmap x a') (inv_V path)).
      *
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
a': Au'
transport idmap path a' = inv_e a' apply transport_path_universe.
Defined.

Lemma monic_set_present_uniqueness : (Au; (mu; (h, mono, p))) = (Au'; (mu'; (h', mono', p'))) :> {A : Type & {m : A -> V & IsHSet A * IsEmbedding m * (u = set m)}}.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
(Au; mu; (h, mono, p)) = (Au'; mu'; (h', mono', p'))
Proof.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
(Au; mu; (h, mono, p)) = (Au'; mu'; (h', mono', p'))
  apply path_sigma_uncurried; simpl.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
{p0 : Au = Au' &
transport
  (fun A : Type =>
   {m : A -> V &
   IsHSet A * IsEmbedding m * (u = set m)}) p0
  (mu; (h, mono, p)) = (mu'; (h', mono', p'))}
  exists path^.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport
  (fun A : Type =>
   {m : A -> V &
   IsHSet A * IsEmbedding m * (u = set m)}) path^
  (mu; (h, mono, p)) = (mu'; (h', mono', p'))
  transitivity (path^ # mu; transportD (fun A => A -> V) (fun A m => IsHSet A * IsEmbedding m * (u = set m)) path^ mu (h, mono, p)).
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport
  (fun A : Type =>
   {m : A -> V &
   IsHSet A * IsEmbedding m * (u = set m)}) path^
  (mu; (h, mono, p)) =
(transport (fun A : Type => A -> V) path^ mu;
transportD (fun A : Type => A -> V)
  (fun (A : Type) (m : (fun A0 : Type => A0 -> V) A)
   => IsHSet A * IsEmbedding m * (u = set m)) path^ mu
  (h, mono, p))
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
(transport (fun A : Type => A -> V) path^ mu;
transportD (fun A : Type => A -> V)
  (fun (A : Type) (m : (fun A0 : Type => A0 -> V) A)
   => IsHSet A * IsEmbedding m * (u = set m)) path^ mu
  (h, mono, p)) = (mu'; (h', mono', p'))
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport
  (fun A : Type =>
   {m : A -> V &
   IsHSet A * IsEmbedding m * (u = set m)}) path^
  (mu; (h, mono, p)) =
(transport (fun A : Type => A -> V) path^ mu;
transportD (fun A : Type => A -> V)
  (fun (A : Type) (m : (fun A0 : Type => A0 -> V) A)
   => IsHSet A * IsEmbedding m * (u = set m)) path^ mu
  (h, mono, p)) exact (@transport_sigma Type (fun A => A -> V) (fun A m => IsHSet A * IsEmbedding m * (u = set m)) Au Au' path^ (mu; (h, mono, p))).
  -
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
(transport (fun A : Type => A -> V) path^ mu;
transportD (fun A : Type => A -> V)
  (fun (A : Type) (m : (fun A0 : Type => A0 -> V) A)
   => IsHSet A * IsEmbedding m * (u = set m)) path^ mu
  (h, mono, p)) = (mu'; (h', mono', p')) apply path_sigma_hprop; simpl.
ua: Univalence
u: V
Au, Au': Type
h: IsHSet Au
h': IsHSet Au'
mu: Au -> V
mono: IsEmbedding mu
mu': Au' -> V
mono': IsEmbedding mu'
p: u = set mu
p': u = set mu'
e:= fun a : Au => (fst eq_img_untrunc a).1: Au -> Au'
inv_e:= fun a' : Au' => (snd eq_img_untrunc a').1: Au' -> Au
hom1:= (fun a' : Au' =>
 isinj_embedding mu' mono' 
   (e (inv_e a')) a'
   ((fst eq_img_untrunc (inv_e a')).2 @
    (snd eq_img_untrunc a').2))
:
e o inv_e == idmap: e o inv_e == idmap
hom2:= (fun a : Au =>
 isinj_embedding mu mono 
   (inv_e (e a)) a
   ((snd eq_img_untrunc (e a)).2 @
    (fst eq_img_untrunc a).2))
:
inv_e o e == idmap: inv_e o e == idmap
path:= path_universe_uncurried
  (equiv_adjointify inv_e e hom2 hom1): Au' = Au
transport (fun A : Type => A -> V) path^ mu = mu'
    exact mu_eq_mu'.
Defined.

End MonicSetPresent_Uniqueness.

(** This lemma actually says a little more than 10.5.6, i.e., that Au is a hSet *)
Lemma monic_set_present : forall u : V, exists (Au : Type) (m : Au -> V),
  (IsHSet Au) * (IsEmbedding m) * (u = set m).
ua: Univalence
forall u : V,
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (u = set m)}}
Proof.
ua: Univalence
forall u : V,
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (u = set m)}}
  apply V_ind_hprop.
ua: Univalence
forall (A : Type) (f : A -> V),
(forall a : A,
 {Au : Type &
 {m : Au -> V &
 IsHSet Au * IsEmbedding m * (f a = set m)}}) ->
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (set f = set m)}}
ua: Univalence
forall v : V,
IsHProp
  {Au : Type &
  {m : Au -> V &
  IsHSet Au * IsEmbedding m * (v = set m)}}
  -
ua: Univalence
forall (A : Type) (f : A -> V),
(forall a : A,
 {Au : Type &
 {m : Au -> V &
 IsHSet Au * IsEmbedding m * (f a = set m)}}) ->
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (set f = set m)}} intros A f _.
ua: Univalence
A: Type
f: A -> V
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (set f = set m)}}
    destruct (quotient_kernel_factor_general f (ker_bisim f) (ker_bisim_is_ker f))
      as [Au [eu [mu (((hset_Au, epi_eu), mono_mu), factor)]]].
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
{Au : Type &
{m : Au -> V &
IsHSet Au * IsEmbedding m * (set f = set m)}}
    exists Au, mu.
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
IsHSet Au * IsEmbedding mu * (set f = set mu) split;[exact (hset_Au, mono_mu)|].
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
set f = set mu
    apply setext'; split.
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
forall a : A, hexists (fun b : Au => f a = mu b)
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
forall b : Au, hexists (fun a : A => f a = mu b)
    +
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
forall a : A, hexists (fun b : Au => f a = mu b) intro a.
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a: A
hexists (fun b : Au => f a = mu b) apply tr; exists (eu a).
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a: A
f a = mu (eu a) exact (ap10 factor a).
    +
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
forall b : Au, hexists (fun a : A => f a = mu b) intro a'.
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
hexists (fun a : A => f a = mu a') generalize (epi_eu a').
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
ReflectiveSubuniverse.IsConnected (Tr (-1))
  (hfiber eu a') -> hexists (fun a : A => f a = mu a')
      intro IC; refine (Trunc_functor (-1) _ (@center _ IC)).
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
hfiber eu a' -> {a : A & f a = mu a'}
      intros [a p].
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
{a : A & f a = mu a'} exists a.
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
f a = mu a' transitivity (mu (eu a)).
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
f a = mu (eu a)
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
mu (eu a) = mu a'
      *
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
f a = mu (eu a) exact (ap10 factor a).
      *
ua: Univalence
A: Type
f: A -> V
Au: Type
eu: A -> Au
mu: Au -> V
hset_Au: IsHSet Au
epi_eu: ReflectiveSubuniverse.IsConnMap (Tr (-1)) eu
mono_mu: IsEmbedding mu
factor: f = (fun x : A => mu (eu x))
a': Au
IC: ReflectiveSubuniverse.IsConnected 
  (Tr (-1)) (hfiber eu a')
a: A
p: eu a = a'
mu (eu a) = mu a' exact (ap mu p).
  -
ua: Univalence
forall v : V,
IsHProp
  {Au : Type &
  {m : Au -> V &
  IsHSet Au * IsEmbedding m * (v = set m)}} intro v.
ua: Univalence
v: V
IsHProp
  {Au : Type &
  {m : Au -> V &
  IsHSet Au * IsEmbedding m * (v = set m)}} apply hprop_allpath.
ua: Univalence
v: V
forall
x
 y : {Au : Type &
     {m : Au -> V &
     IsHSet Au * IsEmbedding m * (v = set m)}}, x = y
    intros [Au [mu ((hset, mono), p)]].
ua: Univalence
v: V
Au: Type
mu: Au -> V
hset: IsHSet Au
mono: IsEmbedding mu
p: v = set mu
forall
y : {Au : Type &
    {m : Au -> V &
    IsHSet Au * IsEmbedding m * (v = set m)}},
(Au; mu; (hset, mono, p)) = y
    intros [Au' [mu' ((hset', mono'), p')]].
ua: Univalence
v: V
Au: Type
mu: Au -> V
hset: IsHSet Au
mono: IsEmbedding mu
p: v = set mu
Au': Type
mu': Au' -> V
hset': IsHSet Au'
mono': IsEmbedding mu'
p': v = set mu'
(Au; mu; (hset, mono, p)) =
(Au'; mu'; (hset', mono', p'))
    exact monic_set_present_uniqueness.
Defined.

Definition type_of_members (u : V) : Type := pr1 (monic_set_present u).

Notation "[ u ]" := (type_of_members u) : set_scope.

Definition func_of_members {u : V} : [u] -> V := pr1 (pr2 (monic_set_present u)) : [u] -> V.

Definition is_hset_typeofmembers {u : V} : IsHSet ([u]) := fst (fst (pr2 (pr2 (monic_set_present u)))).

Definition IsEmbedding_funcofmembers {u : V} : IsEmbedding func_of_members := snd (fst (pr2 (pr2 (monic_set_present u)))).

Definition is_valid_presentation (u : V) : u = set func_of_members := snd (pr2 (pr2 (monic_set_present u))).


(** ** Lemmas 10.5.8 (i) & (vii), we put them here because they are useful later *)
Lemma extensionality : forall {x y : V}, (x ⊆ y * y ⊆ x) <-> x = y.
ua: Univalence
forall x y : V, x ⊆ y * y ⊆ x <-> x = y
Proof.
ua: Univalence
forall x y : V, x ⊆ y * y ⊆ x <-> x = y
  refine (V_ind_hprop _ _ _).
ua: Univalence
forall (A : Type) (f : A -> V),
(forall (a : A) (y : V), f a ⊆ y * y ⊆ f a <-> f a = y) ->
forall y : V, set f ⊆ y * y ⊆ set f <-> set f = y intros A f _.
ua: Univalence
A: Type
f: A -> V
forall y : V, set f ⊆ y * y ⊆ set f <-> set f = y
  refine (V_ind_hprop _ _ _).
ua: Univalence
A: Type
f: A -> V
forall (A0 : Type) (f0 : A0 -> V),
(forall a : A0,
 set f ⊆ f0 a * f0 a ⊆ set f <-> set f = f0 a) ->
set f ⊆ set f0 * set f0 ⊆ set f <-> set f = set f0 intros B g _.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
set f ⊆ set g * set g ⊆ set f <-> set f = set g
  split.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
set f ⊆ set g * set g ⊆ set f -> set f = set g
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
set f = set g -> set f ⊆ set g * set g ⊆ set f
  -
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
set f ⊆ set g * set g ⊆ set f -> set f = set g intros [H1 H2].
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
set f = set g apply setext'.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
equal_img f g split.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
forall a : A, hexists (fun b : B => f a = g b)
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
forall b : B, hexists (fun a : A => f a = g b)
    +
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
forall a : A, hexists (fun b : B => f a = g b) intro.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
a: A
hexists (fun b : B => f a = g b) refine (Trunc_rec _ (H1 (f a) (tr (a;1)))).
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
a: A
{a0 : B & g a0 = f a} ->
hexists (fun b : B => f a = g b)
      intros [b p].
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
a: A
b: B
p: g b = f a
hexists (fun b : B => f a = g b) apply tr.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
a: A
b: B
p: g b = f a
{b : B & f a = g b} exists b.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
a: A
b: B
p: g b = f a
f a = g b exact p^.
    +
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
forall b : B, hexists (fun a : A => f a = g b) intro.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
b: B
hexists (fun a : A => f a = g b) apply (H2 (g b)).
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
H1: set f ⊆ set g
H2: set g ⊆ set f
b: B
g b ∈ set g apply tr; exists b; reflexivity.
  -
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
set f = set g -> set f ⊆ set g * set g ⊆ set f intro p; split.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
set f ⊆ set g
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
set g ⊆ set f
    +
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
set f ⊆ set g intros z Hz.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
z: V
Hz: z ∈ set f
z ∈ set g exact (transport (fun x => z ∈ x) p Hz).
    +
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
set g ⊆ set f intros z Hz.
ua: Univalence
A: Type
f: A -> V
B: Type
g: B -> V
p: set f = set g
z: V
Hz: z ∈ set g
z ∈ set f exact (transport (fun x => z ∈ x) p^ Hz).
Qed.

Lemma mem_induction (C : V -> HProp)
: (forall v, (forall x, x ∈ v -> C x) -> C v) -> forall v, C v.
ua: Univalence
C: V -> HProp
(forall v : V, (forall x : V, x ∈ v -> C x) -> C v) ->
forall v : V, C v
Proof.
ua: Univalence
C: V -> HProp
(forall v : V, (forall x : V, x ∈ v -> C x) -> C v) ->
forall v : V, C v
  intro H.
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
forall v : V, C v
  refine (V_ind_hprop _ _ _).
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
forall (A : Type) (f : A -> V),
(forall a : A, C (f a)) -> C (set f)
  intros A f H_f.
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
A: Type
f: A -> V
H_f: forall a : A, C (f a)
C (set f) apply H.
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
A: Type
f: A -> V
H_f: forall a : A, C (f a)
forall x : V, x ∈ set f -> C x intros x Hx.
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
A: Type
f: A -> V
H_f: forall a : A, C (f a)
x: V
Hx: x ∈ set f
C x
  generalize Hx; apply Trunc_rec.
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
A: Type
f: A -> V
H_f: forall a : A, C (f a)
x: V
Hx: x ∈ set f
{a : A & f a = x} -> C x
  intros [a p].
ua: Univalence
C: V -> HProp
H: forall v : V, (forall x : V, x ∈ v -> C x) -> C v
A: Type
f: A -> V
H_f: forall a : A, C (f a)
x: V
Hx: x ∈ set f
a: A
p: f a = x
C x exact (transport C p (H_f a)).
Defined.

(** ** Two useful lemmas *)

#[export] Instance irreflexive_mem : Irreflexive mem.
ua: Univalence
Irreflexive (fun x x0 : V => x ∈ x0)
Proof.
ua: Univalence
Irreflexive (fun x x0 : V => x ∈ x0)
  assert (forall v, IsHProp (complement (fun x x0 : V => x ∈ x0) v v)). (* https://coq.inria.fr/bugs/show_bug.cgi?id=3854 *)
ua: Univalence
forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
ua: Univalence
X: forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
Irreflexive (fun x x0 : V => x ∈ x0)
  {
ua: Univalence
forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v) intro.
ua: Univalence
v: V
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
    unfold complement.
ua: Univalence
v: V
IsHProp (~ v ∈ v)
    exact _. }
ua: Univalence
X: forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
Irreflexive (fun x x0 : V => x ∈ x0)
  refine (mem_induction (fun x => Build_HProp (~ x ∈ x)) _); simpl in *.
ua: Univalence
X: forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
forall v : V,
(forall x : V, x ∈ v -> ~ x ∈ x) -> ~ v ∈ v
  intros v H.
ua: Univalence
X: forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
v: V
H: forall x : V, x ∈ v -> ~ x ∈ x
~ v ∈ v intro Hv.
ua: Univalence
X: forall v : V,
IsHProp (complement (fun x x0 : V => x ∈ x0) v v)
v: V
H: forall x : V, x ∈ v -> ~ x ∈ x
Hv: v ∈ v
Empty
  exact (H v Hv Hv).
Defined.

Lemma path_V_eqimg {A B} {f : A -> V} {g : B -> V} : set f = set g -> equal_img f g.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
set f = set g -> equal_img f g
Proof.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
set f = set g -> equal_img f g
  intro p.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
equal_img f g split.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
forall a : A, hexists (fun b : B => f a = g b)
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
forall b : B, hexists (fun a : A => f a = g b)
  -
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
forall a : A, hexists (fun b : B => f a = g b) intro a.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
hexists (fun b : B => f a = g b)
    assert (H : f a ∈ set g).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
f a ∈ set g
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
H: f a ∈ set g
hexists (fun b : B => f a = g b)
    {
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
f a ∈ set g apply (snd extensionality p).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
f a ∈ set f
      apply tr; exists a; reflexivity. }
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
H: f a ∈ set g
hexists (fun b : B => f a = g b)
    generalize H; apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
H: f a ∈ set g
{a0 : B & g a0 = f a} -> {b : B & f a = g b} intros [b p'].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
a: A
H: f a ∈ set g
b: B
p': g b = f a
{b : B & f a = g b} exists b; exact p'^.
  -
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
forall b : B, hexists (fun a : A => f a = g b) intro b.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
hexists (fun a : A => f a = g b)
    assert (H : g b ∈ set f).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
g b ∈ set f
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
H: g b ∈ set f
hexists (fun a : A => f a = g b)
    {
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
g b ∈ set f apply (snd extensionality p^).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
g b ∈ set g
      apply tr; exists b; reflexivity. }
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
H: g b ∈ set f
hexists (fun a : A => f a = g b)
    generalize H; apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
H: g b ∈ set f
{a : A & f a = g b} -> {a : A & f a = g b} intros [a p'].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
p: set f = set g
b: B
H: g b ∈ set f
a: A
p': f a = g b
{a : A & f a = g b} exists a; exact p'.
Defined.


(** ** Definitions of particular sets in V *)

(** The empty set *)
Definition V_empty : V := set (Empty_ind (fun _ => V)).

(** The singleton {u} *)
Definition V_singleton (u : V) : V@{U' U} := set (Unit_ind u).

#[export] Instance isequiv_ap_V_singleton {u v : V}
: IsEquiv (@ap _ _ V_singleton u v).
ua: Univalence
u, v: V
IsEquiv (ap V_singleton)
Proof.
ua: Univalence
u, v: V
IsEquiv (ap V_singleton)
  simple refine (Build_IsEquiv _ _ _ _ _ _ _); try solve [ intro; apply path_ishprop ].
ua: Univalence
u, v: V
V_singleton u = V_singleton v -> u = v
  {
ua: Univalence
u, v: V
V_singleton u = V_singleton v -> u = v intro H.
ua: Univalence
u, v: V
H: V_singleton u = V_singleton v
u = v specialize (path_V_eqimg H).
ua: Univalence
u, v: V
H: V_singleton u = V_singleton v
equal_img (Unit_ind u) (Unit_ind v) -> u = v intros (H1, H2).
ua: Univalence
u, v: V
H: V_singleton u = V_singleton v
H1: forall a : Unit,
hexists
  (fun b : Unit => Unit_ind u a = Unit_ind v b)
H2: forall b : Unit,
hexists
  (fun a : Unit => Unit_ind u a = Unit_ind v b)
u = v
    refine (Trunc_rec _ (H1 tt)).
ua: Univalence
u, v: V
H: V_singleton u = V_singleton v
H1: forall a : Unit,
hexists
  (fun b : Unit => Unit_ind u a = Unit_ind v b)
H2: forall b : Unit,
hexists
  (fun a : Unit => Unit_ind u a = Unit_ind v b)
{b : Unit & Unit_ind u tt = Unit_ind v b} -> u = v intros [t p].
ua: Univalence
u, v: V
H: V_singleton u = V_singleton v
H1: forall a : Unit,
hexists
  (fun b : Unit => Unit_ind u a = Unit_ind v b)
H2: forall b : Unit,
hexists
  (fun a : Unit => Unit_ind u a = Unit_ind v b)
t: Unit
p: Unit_ind u tt = Unit_ind v t
u = v destruct t; exact p. }
Defined.

(** The pair {u,v} *)
Definition V_pair (u : V) (v : V) : V@{U' U} := set (fun b : Bool => if b then u else v).

Lemma path_pair {u v u' v' : V@{U' U}} : (u = u') * (v = v') -> V_pair u v = V_pair u' v'.
ua: Univalence
u, v, u', v': V
(u = u') * (v = v') -> V_pair u v = V_pair u' v'
Proof.
ua: Univalence
u, v, u', v': V
(u = u') * (v = v') -> V_pair u v = V_pair u' v'
  intros (H1, H2).
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
V_pair u v = V_pair u' v' apply setext'.
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
equal_img (fun b : Bool => if b then u else v)
  (fun b : Bool => if b then u' else v') split.
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
forall a : Bool,
hexists
  (fun b : Bool =>
   (if a then u else v) = (if b then u' else v'))
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
forall b : Bool,
hexists
  (fun a : Bool =>
   (if a then u else v) = (if b then u' else v'))
  +
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
forall a : Bool,
hexists
  (fun b : Bool =>
   (if a then u else v) = (if b then u' else v')) apply Bool_ind.
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun b : Bool => u = (if b then u' else v'))
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun b : Bool => v = (if b then u' else v'))
    *
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun b : Bool => u = (if b then u' else v')) apply tr; exists true.
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
u = u' assumption.
    *
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun b : Bool => v = (if b then u' else v')) apply tr; exists false; assumption.
  +
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
forall b : Bool,
hexists
  (fun a : Bool =>
   (if a then u else v) = (if b then u' else v')) apply Bool_ind.
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun a : Bool => (if a then u else v) = u')
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun a : Bool => (if a then u else v) = v')
    *
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun a : Bool => (if a then u else v) = u') apply tr; exists true; assumption.
    *
ua: Univalence
u, v, u', v': V
H1: u = u'
H2: v = v'
hexists (fun a : Bool => (if a then u else v) = v') apply tr; exists false; assumption.
Defined.

Lemma pair_eq_singleton {u v w : V} : V_pair u v = V_singleton w <-> (u = w) * (v = w).
ua: Univalence
u, v, w: V
V_pair u v = V_singleton w <-> (u = w) * (v = w)
Proof.
ua: Univalence
u, v, w: V
V_pair u v = V_singleton w <-> (u = w) * (v = w)
  split.
ua: Univalence
u, v, w: V
V_pair u v = V_singleton w -> (u = w) * (v = w)
ua: Univalence
u, v, w: V
(u = w) * (v = w) -> V_pair u v = V_singleton w
  +
ua: Univalence
u, v, w: V
V_pair u v = V_singleton w -> (u = w) * (v = w) intro H.
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
(u = w) * (v = w) destruct (path_V_eqimg H) as (H1, H2).
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
H1: forall a : Bool,
hexists
  (fun b : Unit =>
   (if a then u else v) = Unit_ind w b)
H2: forall b : Unit,
hexists
  (fun a : Bool =>
   (if a then u else v) = Unit_ind w b)
(u = w) * (v = w)
    refine (Trunc_rec _ (H1 true)).
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
H1: forall a : Bool,
hexists
  (fun b : Unit =>
   (if a then u else v) = Unit_ind w b)
H2: forall b : Unit,
hexists
  (fun a : Bool =>
   (if a then u else v) = Unit_ind w b)
{b : Unit & u = Unit_ind w b} -> (u = w) * (v = w) intros [t p]; destruct t.
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
H1: forall a : Bool,
hexists
  (fun b : Unit =>
   (if a then u else v) = Unit_ind w b)
H2: forall b : Unit,
hexists
  (fun a : Bool =>
   (if a then u else v) = Unit_ind w b)
p: u = Unit_ind w tt
(u = w) * (v = w)
    refine (Trunc_rec _ (H1 false)).
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
H1: forall a : Bool,
hexists
  (fun b : Unit =>
   (if a then u else v) = Unit_ind w b)
H2: forall b : Unit,
hexists
  (fun a : Bool =>
   (if a then u else v) = Unit_ind w b)
p: u = Unit_ind w tt
{b : Unit & v = Unit_ind w b} -> (u = w) * (v = w) intros [t p']; destruct t.
ua: Univalence
u, v, w: V
H: V_pair u v = V_singleton w
H1: forall a : Bool,
hexists
  (fun b : Unit =>
   (if a then u else v) = Unit_ind w b)
H2: forall b : Unit,
hexists
  (fun a : Bool =>
   (if a then u else v) = Unit_ind w b)
p: u = Unit_ind w tt
p': v = Unit_ind w tt
(u = w) * (v = w)
    split; [exact p| exact p'].
  +
ua: Univalence
u, v, w: V
(u = w) * (v = w) -> V_pair u v = V_singleton w intros (p1, p2).
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
V_pair u v = V_singleton w apply setext'; split.
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
forall a : Bool,
hexists
  (fun b : Unit => (if a then u else v) = Unit_ind w b)
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
forall b : Unit,
hexists
  (fun a : Bool => (if a then u else v) = Unit_ind w b)
    *
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
forall a : Bool,
hexists
  (fun b : Unit => (if a then u else v) = Unit_ind w b) intro a; apply tr; exists tt.
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
a: Bool
(if a then u else v) = Unit_ind w tt destruct a; [exact p1 | exact p2].
    *
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
forall b : Unit,
hexists
  (fun a : Bool => (if a then u else v) = Unit_ind w b) intro t; apply tr; exists true.
ua: Univalence
u, v, w: V
p1: u = w
p2: v = w
t: Unit
u = Unit_ind w t destruct t; exact p1.
Defined.

(** The ordered pair (u,v) *)
Definition V_pair_ord (u : V) (v : V) : V := V_pair (V_singleton u) (V_pair u v).

Notation " [ u , v ] " := (V_pair_ord u v) : set_scope.

Lemma path_pair_ord {a b c d : V} : [a, b] = [c, d] <-> (a = c) * (b = d).
ua: Univalence
a, b, c, d: V
[a, b] = [c, d] <-> (a = c) * (b = d)
Proof.
ua: Univalence
a, b, c, d: V
[a, b] = [c, d] <-> (a = c) * (b = d)
  split.
ua: Univalence
a, b, c, d: V
[a, b] = [c, d] -> (a = c) * (b = d)
ua: Univalence
a, b, c, d: V
(a = c) * (b = d) -> [a, b] = [c, d]
  -
ua: Univalence
a, b, c, d: V
[a, b] = [c, d] -> (a = c) * (b = d) intro p.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
(a = c) * (b = d) assert (p1 : a = c).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
a = c
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
(a = c) * (b = d)
    +
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
a = c assert (H : V_singleton a ∈ [c, d]).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
V_singleton a ∈ [c, d]
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
a = c
      {
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
V_singleton a ∈ [c, d] apply (snd extensionality p).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
V_singleton a ∈ [a, b] simpl.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
Tr (-1)
  {a0 : Bool &
  (if a0 then V_singleton a else V_pair a b) =
  V_singleton a}
        apply tr; exists true; reflexivity. }
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
a = c
      refine (Trunc_rec _ H).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
{a0 : Bool &
(if a0 then V_singleton c else V_pair c d) =
V_singleton a} -> a = c intros [t p']; destruct t.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
p': V_singleton c = V_singleton a
a = c
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
p': V_pair c d = V_singleton a
a = c
      *
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
p': V_singleton c = V_singleton a
a = c exact ((ap V_singleton)^-1 p'^).
      *
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
H: V_singleton a ∈ [c, d]
p': V_pair c d = V_singleton a
a = c symmetry; apply (fst pair_eq_singleton p').
    +
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
(a = c) * (b = d) split.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
a = c
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
b = d
      *
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
a = c exact p1.
      *
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
b = d assert (H : hor (b = c) (b = d)).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
hor (b = c) (b = d)
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
b = d
        {
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
hor (b = c) (b = d) assert (H' : V_pair a b ∈ [c, d]).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
V_pair a b ∈ [c, d]
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
hor (b = c) (b = d)
          {
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
V_pair a b ∈ [c, d] apply (snd extensionality p).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
V_pair a b ∈ [a, b]
            apply tr; exists false; reflexivity. }
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
hor (b = c) (b = d)
          refine (Trunc_rec _ H').
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
{a0 : Bool &
(if a0 then V_singleton c else V_pair c d) =
V_pair a b} -> hor (b = c) (b = d) intros [t p']; destruct t.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_singleton c = V_pair a b
hor (b = c) (b = d)
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
hor (b = c) (b = d)
          -
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_singleton c = V_pair a b
hor (b = c) (b = d) apply tr; left.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_singleton c = V_pair a b
b = c apply (fst pair_eq_singleton p'^).
          -
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
hor (b = c) (b = d) destruct (path_V_eqimg p') as (H1, H2).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
hor (b = c) (b = d)
            generalize (H2 false); apply (Trunc_functor (-1)).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
{a : Bool & (if a then c else d) = b} ->
(b = c) + (b = d)
            intros [t p'']; destruct t.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
p'': c = b
(b = c) + (b = d)
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
p'': d = b
(b = c) + (b = d)
            +
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
p'': c = b
(b = c) + (b = d) left; exact p''^.
            +
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H': V_pair a b ∈ [c, d]
p': V_pair c d = V_pair a b
H1: forall a0 : Bool,
hexists
  (fun b0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
H2: forall b0 : Bool,
hexists
  (fun a0 : Bool =>
   (if a0 then c else d) = (if b0 then a else b))
p'': d = b
(b = c) + (b = d) right; exact p''^. }
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
b = d
        refine (Trunc_rec _ H).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
(b = c) + (b = d) -> b = d intro case; destruct case as [p'| p'].
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
b = d
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = d
b = d
        2: assumption.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
b = d
        assert (H' : [a, b] = V_singleton (V_singleton b)).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
[a, b] = V_singleton (V_singleton b)
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
H': [a, b] = V_singleton (V_singleton b)
b = d
        {
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
[a, b] = V_singleton (V_singleton b) apply (snd pair_eq_singleton).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
(V_singleton a = V_singleton b) *
(V_pair a b = V_singleton b)
          split.
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
V_singleton a = V_singleton b
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
V_pair a b = V_singleton b
          -
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
V_singleton a = V_singleton b apply ap; exact (p1 @ p'^).
          -
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
V_pair a b = V_singleton b apply (snd pair_eq_singleton).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
(a = b) * (b = b)
            split; [exact (p1 @ p'^) | reflexivity]. }
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
H': [a, b] = V_singleton (V_singleton b)
b = d
        assert (H'' : V_pair c d = V_singleton b)
          by apply (fst pair_eq_singleton (p^ @ H')).
ua: Univalence
a, b, c, d: V
p: [a, b] = [c, d]
p1: a = c
H: hor (b = c) (b = d)
p': b = c
H': [a, b] = V_singleton (V_singleton b)
H'': V_pair c d = V_singleton b
b = d
        symmetry; apply (fst pair_eq_singleton H'').
  -
ua: Univalence
a, b, c, d: V
(a = c) * (b = d) -> [a, b] = [c, d] intros (p, p').
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
[a, b] = [c, d]
    apply path_pair.
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
(V_singleton a = V_singleton c) *
(V_pair a b = V_pair c d) split.
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
V_singleton a = V_singleton c
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
V_pair a b = V_pair c d
    +
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
V_singleton a = V_singleton c apply ap; exact p.
    +
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
V_pair a b = V_pair c d apply path_pair.
ua: Univalence
a, b, c, d: V
p: a = c
p': b = d
(a = c) * (b = d) split; assumption; assumption.
Defined.

(** The cartesian product a × b *)
Definition V_cart_prod (a : V) (b : V) : V
:= set (fun x : [a] * [b] => [func_of_members (fst x), func_of_members (snd x)]).

Notation " a × b " := (V_cart_prod a b) : set_scope.

(** f is a function with domain a and codomain b *)
Definition V_is_func (a : V) (b : V) (f : V) := f ⊆ (a × b)
 * (forall x, x ∈ a -> hexists (fun y => y ∈ b * [x,y] ∈ f))
 * (forall x y y', [x,y] ∈ f * [x,y'] ∈ f -> y = y').

(** The set of functions from a to b *)
Definition V_func (a : V) (b : V) : V
:= @set ([a] -> [b]) (fun f => set (fun x => [func_of_members x, func_of_members (f x)] )).

(** The union of a set Uv *)
Definition V_union (v : V) :=
  @set ({x : [v] & [func_of_members x]}) (fun z => func_of_members (pr2 z)).

(** The ordinal successor x ∪ {x} *)
Definition V_succ : V -> V.
ua: Univalence
V -> V
Proof.
ua: Univalence
V -> V
  simple refine (V_rec' _ _ _ _).
ua: Univalence
forall A : Type, (A -> V) -> (A -> V) -> V
ua: Univalence
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> V) (H_g : B -> V),
equal_img H_f H_g -> ?H_set A f H_f = ?H_set B g H_g
  -
ua: Univalence
forall A : Type, (A -> V) -> (A -> V) -> V intros A f _.
ua: Univalence
A: Type
f: A -> V
V
    exact (set (fun (x : A + Unit) => match x with inl a => f a
                                           | inr tt => set f end)).
  -
ua: Univalence
forall (A B : Type) (f : A -> V) (g : B -> V),
equal_img f g ->
forall (H_f : A -> V) (H_g : B -> V),
equal_img H_f H_g ->
(fun (A0 : Type) (f0 _ : A0 -> V) =>
 set
   (fun x : A0 + Unit =>
    match x with
    | inl a => f0 a
    | inr tt => set f0
    end)) A f H_f =
(fun (A0 : Type) (f0 _ : A0 -> V) =>
 set
   (fun x : A0 + Unit =>
    match x with
    | inl a => f0 a
    | inr tt => set f0
    end)) B g H_g simpl; intros A B f g eq_img _ _ _.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
set
  (fun x : A + Unit =>
   match x with
   | inl a => f a
   | inr tt => set f
   end) =
set
  (fun x : B + Unit =>
   match x with
   | inl a => g a
   | inr tt => set g
   end) apply setext'.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
equal_img
  (fun x : A + Unit =>
   match x with
   | inl a => f a
   | inr tt => set f
   end)
  (fun x : B + Unit =>
   match x with
   | inl a => g a
   | inr tt => set g
   end) split.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
forall a : A + Unit,
hexists
  (fun b : B + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end =
   match b with
   | inl a0 => g a0
   | inr tt => set g
   end)
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
forall b : B + Unit,
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end =
   match b with
   | inl a0 => g a0
   | inr tt => set g
   end)
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
forall a : A + Unit,
hexists
  (fun b : B + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end =
   match b with
   | inl a0 => g a0
   | inr tt => set g
   end) intro.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A + Unit
hexists
  (fun b : B + Unit =>
   match a with
   | inl a => f a
   | inr tt => set f
   end =
   match b with
   | inl a => g a
   | inr tt => set g
   end) destruct a.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A
hexists
  (fun b : B + Unit =>
   f a =
   match b with
   | inl a => g a
   | inr tt => set g
   end)
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
hexists
  (fun b : B + Unit =>
   match u with
   | tt => set f
   end =
   match b with
   | inl a => g a
   | inr tt => set g
   end)
      *
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A
hexists
  (fun b : B + Unit =>
   f a =
   match b with
   | inl a => g a
   | inr tt => set g
   end) generalize (fst eq_img a).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A
hexists (fun b : B => f a = g b) ->
hexists
  (fun b : B + Unit =>
   f a =
   match b with
   | inl a => g a
   | inr tt => set g
   end) apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A
{b : B & f a = g b} ->
{b : B + Unit &
f a =
match b with
| inl a => g a
| inr tt => set g
end}
        intros [b p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
a: A
b: B
p: f a = g b
{b : B + Unit &
f a =
match b with
| inl a => g a
| inr tt => set g
end} exists (inl b); exact p.
      *
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
hexists
  (fun b : B + Unit =>
   match u with
   | tt => set f
   end =
   match b with
   | inl a => g a
   | inr tt => set g
   end) apply tr; exists (inr tt).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
match u with
| tt => set f
end = set g destruct u.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
set f = set g apply setext'; auto.
    +
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
forall b : B + Unit,
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end =
   match b with
   | inl a0 => g a0
   | inr tt => set g
   end) intro.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B + Unit
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end =
   match b with
   | inl a0 => g a0
   | inr tt => set g
   end) destruct b.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end = g b)
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end = match u with
         | tt => set g
         end)
      *
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end = g b) generalize (snd eq_img b).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B
hexists (fun a : A => f a = g b) ->
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end = g b) apply (Trunc_functor (-1)).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B
{a : A & f a = g b} ->
{a : A + Unit &
match a with
| inl a0 => f a0
| inr tt => set f
end = g b}
        intros [a p].
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
b: B
a: A
p: f a = g b
{a : A + Unit &
match a with
| inl a0 => f a0
| inr tt => set f
end = g b} exists (inl a); exact p.
      *
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
hexists
  (fun a : A + Unit =>
   match a with
   | inl a0 => f a0
   | inr tt => set f
   end = match u with
         | tt => set g
         end) apply tr; exists (inr tt).
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
u: Unit
set f = match u with
        | tt => set g
        end destruct u.
ua: Univalence
A, B: Type
f: A -> V
g: B -> V
eq_img: equal_img f g
set f = set g apply setext'; auto.
Defined.

(** The set of finite ordinals *)
Definition V_omega : V
:= set (fix I n := match n with 0   => V_empty
                              | S n => V_succ (I n) end).


(** ** Axioms of set theory (theorem 10.5.8) *)

Lemma not_mem_Vempty : forall x, ~ (x ∈ V_empty).
ua: Univalence
forall x : V, ~ x ∈ V_empty
Proof.
ua: Univalence
forall x : V, ~ x ∈ V_empty
  intros x Hx.
ua: Univalence
x: V
Hx: x ∈ V_empty
Empty generalize Hx; apply Trunc_rec.
ua: Univalence
x: V
Hx: x ∈ V_empty
{a : Empty & Empty_ind (fun _ : Empty => V) a = x} ->
Empty
  intros [ff _].
ua: Univalence
x: V
Hx: x ∈ V_empty
ff: Empty
Empty exact ff.
Qed.

Lemma pairing : forall u v, hexists (fun w => forall x, x ∈ w <-> hor (x = u) (x = v)).
ua: Univalence
forall u v : V,
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> hor (x = u) (x = v))
Proof.
ua: Univalence
forall u v : V,
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> hor (x = u) (x = v))
  intros u v.
ua: Univalence
u, v: V
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> hor (x = u) (x = v)) apply tr.
ua: Univalence
u, v: V
{w : V & forall x : V, x ∈ w <-> hor (x = u) (x = v)} exists (V_pair u v).
ua: Univalence
u, v: V
forall x : V, x ∈ V_pair u v <-> hor (x = u) (x = v)
  intro; split; apply (Trunc_functor (-1)).
ua: Univalence
u, v, x: V
{a : Bool & (if a then u else v) = x} ->
(x = u) + (x = v)
ua: Univalence
u, v, x: V
(x = u) + (x = v) ->
{a : Bool & (if a then u else v) = x}
  -
ua: Univalence
u, v, x: V
{a : Bool & (if a then u else v) = x} ->
(x = u) + (x = v) intros [[|] p]; [left|right]; exact p^.
  -
ua: Univalence
u, v, x: V
(x = u) + (x = v) ->
{a : Bool & (if a then u else v) = x} intros [p | p]; [exists true | exists false]; exact p^.
Qed.

Lemma infinity : (V_empty ∈ V_omega) * (forall x, x ∈ V_omega -> V_succ x ∈ V_omega).
ua: Univalence
V_empty ∈ V_omega *
(forall x : V, x ∈ V_omega -> V_succ x ∈ V_omega)
Proof.
ua: Univalence
V_empty ∈ V_omega *
(forall x : V, x ∈ V_omega -> V_succ x ∈ V_omega)
  split.
ua: Univalence
V_empty ∈ V_omega
ua: Univalence
forall x : V, x ∈ V_omega -> V_succ x ∈ V_omega
  -
ua: Univalence
V_empty ∈ V_omega apply tr; exists 0; auto.
  -
ua: Univalence
forall x : V, x ∈ V_omega -> V_succ x ∈ V_omega intro.
ua: Univalence
x: V
x ∈ V_omega -> V_succ x ∈ V_omega apply (Trunc_functor (-1)).
ua: Univalence
x: V
{a : nat &
(fix I (n : nat) : V :=
   match n with
   | 0 => V_empty
   | n0.+1 => V_succ (I n0)
   end) a = x} ->
{a : nat &
(fix I (n : nat) : V :=
   match n with
   | 0 => V_empty
   | n0.+1 => V_succ (I n0)
   end) a = V_succ x}
    intros [n p].
ua: Univalence
x: V
n: nat
p: (fix I (n : nat) : V :=
   match n with
   | 0 => V_empty
   | n0.+1 => V_succ (I n0)
   end) n = x
{a : nat &
(fix I (n : nat) : V :=
   match n with
   | 0 => V_empty
   | n0.+1 => V_succ (I n0)
   end) a = V_succ x} exists (S n).
ua: Univalence
x: V
n: nat
p: (fix I (n : nat) : V :=
   match n with
   | 0 => V_empty
   | n0.+1 => V_succ (I n0)
   end) n = x
V_succ
  ((fix I (n : nat) : V :=
      match n with
      | 0 => V_empty
      | n0.+1 => V_succ (I n0)
      end) n) = V_succ x rewrite p; auto.
Qed.

Lemma union : forall v, hexists (fun w => forall x, x ∈ w <-> hexists (fun u => x ∈ u * u ∈ v)).
ua: Univalence
forall v : V,
hexists
  (fun w : V =>
   forall x : V,
   x ∈ w <-> hexists (fun u : V => x ∈ u * u ∈ v))
Proof.
ua: Univalence
forall v : V,
hexists
  (fun w : V =>
   forall x : V,
   x ∈ w <-> hexists (fun u : V => x ∈ u * u ∈ v))
  intro v.
ua: Univalence
v: V
hexists
  (fun w : V =>
   forall x : V,
   x ∈ w <-> hexists (fun u : V => x ∈ u * u ∈ v)) apply tr; exists (V_union v).
ua: Univalence
v: V
forall x : V,
x ∈ V_union v <-> hexists (fun u : V => x ∈ u * u ∈ v)
  intro x; split.
ua: Univalence
v, x: V
x ∈ V_union v -> hexists (fun u : V => x ∈ u * u ∈ v)
ua: Univalence
v, x: V
hexists (fun u : V => x ∈ u * u ∈ v) -> x ∈ V_union v
  -
ua: Univalence
v, x: V
x ∈ V_union v -> hexists (fun u : V => x ∈ u * u ∈ v) intro H.
ua: Univalence
v, x: V
H: x ∈ V_union v
hexists (fun u : V => x ∈ u * u ∈ v) simpl in H.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
hexists (fun u : V => x ∈ u * u ∈ v) generalize H; apply (Trunc_functor (-1)).
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
{a : {x : [v] & [func_of_members x]} &
func_of_members a.2 = x} -> {u : V & x ∈ u * u ∈ v}
    intros [[u' x'] p]; simpl in p.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
{u : V & x ∈ u * u ∈ v}
    exists (func_of_members u'); split.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
x ∈ func_of_members u'
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
func_of_members u' ∈ v
    +
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
x ∈ func_of_members u' refine (transport (fun z => x ∈ z) (is_valid_presentation (func_of_members u'))^ _).
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
x ∈ set func_of_members
      simpl.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
Tr (-1)
  {a : [func_of_members u'] & func_of_members a = x} apply tr; exists x'.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
func_of_members x' = x exact p.
    +
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
func_of_members u' ∈ v refine (transport (fun z => func_of_members u' ∈ z) (is_valid_presentation v)^ _).
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
func_of_members u' ∈ set func_of_members
      simpl.
ua: Univalence
v, x: V
H: Tr (-1)
  {a : {x : [v] & [func_of_members x]} &
  func_of_members a.2 = x}
u': [v]
x': [func_of_members u']
p: func_of_members x' = x
Tr (-1)
  {a : [v] & func_of_members a = func_of_members u'} apply tr; exists u'; reflexivity.
  -
ua: Univalence
v, x: V
hexists (fun u : V => x ∈ u * u ∈ v) -> x ∈ V_union v apply Trunc_rec.
ua: Univalence
v, x: V
{u : V & x ∈ u * u ∈ v} -> x ∈ V_union v intros [u (Hx, Hu)].
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
x ∈ V_union v
    generalize (transport (fun z => u ∈ z) (is_valid_presentation v) Hu).
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u ∈ set func_of_members -> x ∈ V_union v
    apply Trunc_rec.
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
{a : [v] & func_of_members a = u} -> x ∈ V_union v intros [u' pu].
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
x ∈ V_union v
    generalize (transport (fun z => x ∈ z) (is_valid_presentation (func_of_members u')) (transport (fun z => x ∈ z) pu^ Hx)).
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
x ∈ set func_of_members -> x ∈ V_union v
    apply Trunc_rec.
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
{a : [func_of_members u'] & func_of_members a = x} ->
x ∈ V_union v intros [x' px].
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
x': [func_of_members u']
px: func_of_members x' = x
x ∈ V_union v
    apply tr.
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
x': [func_of_members u']
px: func_of_members x' = x
{a : {x : [v] & [func_of_members x]} &
func_of_members a.2 = x} exists (u'; x').
ua: Univalence
v, x, u: V
Hx: x ∈ u
Hu: u ∈ v
u': [v]
pu: func_of_members u' = u
x': [func_of_members u']
px: func_of_members x' = x
func_of_members (u'; x').2 = x exact px.
Qed.

Lemma function : forall u v, hexists (fun w => forall x, x ∈ w <-> V_is_func u v x).
ua: Univalence
forall u v : V,
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> V_is_func u v x)
Proof.
ua: Univalence
forall u v : V,
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> V_is_func u v x)
  intros u v.
ua: Univalence
u, v: V
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> V_is_func u v x) apply tr; exists (V_func u v).
ua: Univalence
u, v: V
forall x : V, x ∈ V_func u v <-> V_is_func u v x
  assert (memb_u : u = set (@func_of_members u)) by exact (is_valid_presentation u).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
forall x : V, x ∈ V_func u v <-> V_is_func u v x
  assert (memb_v : v = set (@func_of_members v)) by exact (is_valid_presentation v).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
forall x : V, x ∈ V_func u v <-> V_is_func u v x
  intro phi; split.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
phi ∈ V_func u v -> V_is_func u v phi
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
V_is_func u v phi -> phi ∈ V_func u v
  -
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
phi ∈ V_func u v -> V_is_func u v phi intro H.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
V_is_func u v phi split;[split|].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
phi ⊆ (u × v)
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
forall x : V,
x ∈ u -> hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
    +
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
phi ⊆ (u × v) intros z Hz.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
z: V
Hz: z ∈ phi
z ∈ (u × v) simpl in *.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
Tr (-1)
  {a : [u] * [v] &
  [func_of_members (fst a), func_of_members (snd a)] =
  z} generalize H.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) = phi} ->
Tr (-1)
  {a : [u] * [v] &
  [func_of_members (fst a), func_of_members (snd a)] =
  z} apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
{a : [u] -> [v] &
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (a x)]) = phi} ->
Tr (-1)
  {a : [u] * [v] &
  [func_of_members (fst a), func_of_members (snd a)] =
  z}
      intros [h p_phi].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
Tr (-1)
  {a : [u] * [v] &
  [func_of_members (fst a), func_of_members (snd a)] =
  z} generalize (transport (fun x => z ∈ x) p_phi^ Hz).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
z
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x)]) ->
Tr (-1)
  {a : [u] * [v] &
  [func_of_members (fst a), func_of_members (snd a)] =
  z} apply (Trunc_functor (-1)).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
{a : [u] &
[func_of_members a, func_of_members (h a)] = z} ->
{a : [u] * [v] &
[func_of_members (fst a), func_of_members (snd a)] = z}
      intros [a p].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] = z
{a : [u] * [v] &
[func_of_members (fst a), func_of_members (snd a)] = z} exists (a, h a).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) =
  phi}
z: V
Hz: z ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] = z
[func_of_members (fst (a, h a)),
func_of_members (snd (a, h a))] = z assumption.
    +
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
forall x : V,
x ∈ u -> hexists (fun y : V => y ∈ v * [x, y] ∈ phi) intros x Hx.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
hexists (fun y : V => y ∈ v * [x, y] ∈ phi) generalize (transport (fun y => x ∈ y) memb_u Hx).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
x ∈ set func_of_members ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
      apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
{a : [u] & func_of_members a = x} ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi) intros [a p].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
hexists (fun y : V => y ∈ v * [x, y] ∈ phi) generalize H; apply (Trunc_functor (-1)).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
{a : [u] -> [v] &
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (a x)]) = phi} ->
{y : V & y ∈ v * [x, y] ∈ phi}
      intros [h p_phi].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
{y : V & y ∈ v * [x, y] ∈ phi} exists (func_of_members (h a)).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
func_of_members (h a) ∈ v *
[x, func_of_members (h a)] ∈ phi split.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
func_of_members (h a) ∈ v
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
[x, func_of_members (h a)] ∈ phi
      *
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
func_of_members (h a) ∈ v exact (transport (fun z => func_of_members (h a) ∈ z) memb_v^ (tr (h a; 1))).
      *
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
[x, func_of_members (h a)] ∈ phi apply (transport (fun y => [x, func_of_members (h a)] ∈ y) p_phi).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
[x, func_of_members (h a)]
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x)])
        apply tr; exists a.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x: V
Hx: x ∈ u
a: [u]
p: func_of_members a = x
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
[func_of_members a, func_of_members (h a)] =
[x, func_of_members (h a)] rewrite p; reflexivity.
    +
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y' intros x y y' (Hy, Hy').
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
y = y' generalize H; apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
{a : [u] -> [v] &
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (a x)]) = phi} ->
y = y' intros [h p_phi].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
y = y'
      generalize (transport (fun z => [x, y] ∈ z) p_phi^ Hy).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
[x, y]
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x)]) ->
y = y' apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
{a : [u] &
[func_of_members a, func_of_members (h a)] = [x, y]} ->
y = y' intros [a p].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
y = y'
      generalize (transport (fun z => [x, y'] ∈ z) p_phi^ Hy').
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
[x, y']
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x)]) ->
y = y' apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
{a : [u] &
[func_of_members a, func_of_members (h a)] = [x, y']} ->
y = y' intros [a' p'].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
y = y'
      destruct (fst path_pair_ord p) as (px, py).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
y = y' destruct (fst path_pair_ord p') as (px', py').
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
px': func_of_members a' = x
py': func_of_members (h a') = y'
y = y'
      transitivity (func_of_members (h a)); auto with path_hints.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
px': func_of_members a' = x
py': func_of_members (h a') = y'
func_of_members (h a) = y' transitivity (func_of_members (h a'));auto with path_hints.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
px': func_of_members a' = x
py': func_of_members (h a') = y'
func_of_members (h a) = func_of_members (h a')
      refine (ap func_of_members _).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
px': func_of_members a' = x
py': func_of_members (h a') = y'
h a = h a' refine (ap h _).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H: phi ∈ V_func u v
x, y, y': V
Hy: [x, y] ∈ phi
Hy': [x, y'] ∈ phi
h: [u] -> [v]
p_phi: set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x)]) =
phi
a: [u]
p: [func_of_members a, func_of_members (h a)] =
[x, y]
a': [u]
p': [func_of_members a', func_of_members (h a')] =
[x, y']
px: func_of_members a = x
py: func_of_members (h a) = y
px': func_of_members a' = x
py': func_of_members (h a') = y'
a = a'
      exact (isinj_embedding func_of_members IsEmbedding_funcofmembers a a' (px @ px'^)).
  -
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
V_is_func u v phi -> phi ∈ V_func u v intros ((H1, H2), H3).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
phi ∈ V_func u v simpl.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) = phi}
    assert (h : forall a : [u], {b : [v] & [func_of_members a, func_of_members b] ∈ phi}).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) = phi}
    {
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi} intro a.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi} pose (x := func_of_members a).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
      transparent assert (H : {y : V & y ∈ v * [x, y] ∈ phi}).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
{y : V & y ∈ v * [x, y] ∈ phi}
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
H:= ?Goal0: {y : V & y ∈ v * [x, y] ∈ phi}
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
      -
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
{y : V & y ∈ v * [x, y] ∈ phi} refine (@untrunc_istrunc (-1) {y : V & y ∈ v * [x, y] ∈ phi} _
                                 (H2 x (transport (fun z => x ∈ z) memb_u^ (tr (a; 1))))).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
IsHProp {y : V & y ∈ v * [x, y] ∈ phi}
        apply hprop_allpath.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
forall x0 y : {y : V & y ∈ v * [x, y] ∈ phi}, x0 = y intros [y (H1_y, H2_y)] [y' (H1_y', H2_y')].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
y': V
H1_y': y' ∈ v
H2_y': [x, y'] ∈ phi
(y; (H1_y, H2_y)) = (y'; (H1_y', H2_y'))
        apply path_sigma_uncurried; simpl.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
y': V
H1_y': y' ∈ v
H2_y': [x, y'] ∈ phi
{p : y = y' &
transport (fun y : V => y ∈ v * [x, y] ∈ phi) p
  (H1_y, H2_y) = (H1_y', H2_y')}
        exists (H3 x y y' (H2_y, H2_y')).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
y': V
H1_y': y' ∈ v
H2_y': [x, y'] ∈ phi
transport (fun y : V => y ∈ v * [x, y] ∈ phi)
  (H3 x y y' (H2_y, H2_y')) (H1_y, H2_y) =
(H1_y', H2_y')
        apply path_ishprop.
      -
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
H:= untrunc_istrunc (-1)
  (H2 x
     (transport (fun z : V => x ∈ z) memb_u^
        (tr (a; 1)))): {y : V & y ∈ v * [x, y] ∈ phi}
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi} destruct H as [y (H1_y, H2_y)].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
        destruct (@untrunc_istrunc (-1) _ (IsEmbedding_funcofmembers y) (transport (fun z => y ∈ z) memb_v H1_y)) as [b Hb].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
b: [v]
Hb: func_of_members b = y
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
        exists b.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
a: [u]
x:= func_of_members a: V
y: V
H1_y: y ∈ v
H2_y: [x, y] ∈ phi
b: [v]
Hb: func_of_members b = y
[func_of_members a, func_of_members b] ∈ phi exact (transport (fun z => [x, z] ∈ phi) Hb^ H2_y). }
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
Tr (-1)
  {a : [u] -> [v] &
  set
    (fun x : [u] =>
     [func_of_members x, func_of_members (a x)]) = phi}
    apply tr; exists (fun a => pr1 (h a)).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x).1]) = phi apply extensionality.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x).1]) ⊆ phi *
phi
⊆ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1]) split.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x).1]) ⊆ phi
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
phi
⊆ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1])
    +
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
set
  (fun x : [u] =>
   [func_of_members x, func_of_members (h x).1]) ⊆ phi intros z Hz.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1])
z ∈ phi generalize Hz; apply Trunc_rec.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1])
{a : [u] &
[func_of_members a, func_of_members (h a).1] = z} ->
z ∈ phi intros [a Ha].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1])
a: [u]
Ha: [func_of_members a, func_of_members (h a).1] = z
z ∈ phi
      exact (transport (fun w => w ∈ phi) Ha (pr2 (h a))).
    +
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
phi
⊆ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1]) intros z Hz.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
z
∈ set
    (fun x : [u] =>
     [func_of_members x, func_of_members (h x).1]) simpl.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
Tr (-1)
  {a : [u] &
  [func_of_members a, func_of_members (h a).1] = z}
      generalize (H1 z Hz).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
z ∈ (u × v) ->
Tr (-1)
  {a : [u] &
  [func_of_members a, func_of_members (h a).1] = z} apply (Trunc_functor (-1)).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
{a : [u] * [v] &
[func_of_members (fst a), func_of_members (snd a)] = z} ->
{a : [u] &
[func_of_members a, func_of_members (h a).1] = z} intros [(a,b) p].
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members (fst (a, b)),
func_of_members (snd (a, b))] = z
{a : [u] &
[func_of_members a, func_of_members (h a).1] = z} simpl in p.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
{a : [u] &
[func_of_members a, func_of_members (h a).1] = z}
      exists a.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members (h a).1] = z transitivity ([func_of_members a, func_of_members b]); auto with path_hints.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members (h a).1] =
[func_of_members a, func_of_members b]
      apply ap.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
func_of_members (h a).1 = func_of_members b
      apply H3 with (func_of_members a).
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members (h a).1] ∈ phi *
[func_of_members a, func_of_members b] ∈ phi split.
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members (h a).1] ∈ phi
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members b] ∈ phi
      *
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members (h a).1] ∈ phi exact (pr2 (h a)).
      *
ua: Univalence
u, v: V
memb_u: u = set func_of_members
memb_v: v = set func_of_members
phi: V
H1: phi ⊆ (u × v)
H2: forall x : V,
x ∈ u ->
hexists (fun y : V => y ∈ v * [x, y] ∈ phi)
H3: forall x y y' : V,
[x, y] ∈ phi * [x, y'] ∈ phi -> y = y'
h: forall a : [u],
{b : [v] &
[func_of_members a, func_of_members b] ∈ phi}
z: V
Hz: z ∈ phi
a: [u]
b: [v]
p: [func_of_members a, func_of_members b] = z
[func_of_members a, func_of_members b] ∈ phi exact (transport (fun w => w ∈ phi) p^ Hz).
Qed.

Lemma replacement : forall (r : V -> V) (x : V),
  hexists (fun w => forall y, y ∈ w <-> hexists (fun z => z ∈ x * (r z = y))).
ua: Univalence
forall (r : V -> V) (x : V),
hexists
  (fun w : V =>
   forall y : V,
   y ∈ w <-> hexists (fun z : V => z ∈ x * (r z = y)))
Proof.
ua: Univalence
forall (r : V -> V) (x : V),
hexists
  (fun w : V =>
   forall y : V,
   y ∈ w <-> hexists (fun z : V => z ∈ x * (r z = y)))
  intro r.
ua: Univalence
r: V -> V
forall x : V,
hexists
  (fun w : V =>
   forall y : V,
   y ∈ w <-> hexists (fun z : V => z ∈ x * (r z = y))) refine (V_ind_hprop _ _ _).
ua: Univalence
r: V -> V
forall (A : Type) (f : A -> V),
(forall a : A,
 hexists
   (fun w : V =>
    forall y : V,
    y ∈ w <->
    hexists (fun z : V => z ∈ f a * (r z = y)))) ->
hexists
  (fun w : V =>
   forall y : V,
   y ∈ w <->
   hexists (fun z : V => z ∈ set f * (r z = y)))
  intros A f _.
ua: Univalence
r: V -> V
A: Type
f: A -> V
hexists
  (fun w : V =>
   forall y : V,
   y ∈ w <->
   hexists (fun z : V => z ∈ set f * (r z = y))) apply tr.
ua: Univalence
r: V -> V
A: Type
f: A -> V
{w : V &
forall y : V,
y ∈ w <-> hexists (fun z : V => z ∈ set f * (r z = y))} exists (set (r o f)).
ua: Univalence
r: V -> V
A: Type
f: A -> V
forall y : V,
y ∈ set (fun x : A => r (f x)) <->
hexists (fun z : V => z ∈ set f * (r z = y)) split.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
y ∈ set (fun x : A => r (f x)) ->
hexists (fun z : V => z ∈ set f * (r z = y))
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
hexists (fun z : V => z ∈ set f * (r z = y)) ->
y ∈ set (fun x : A => r (f x))
  -
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
y ∈ set (fun x : A => r (f x)) ->
hexists (fun z : V => z ∈ set f * (r z = y)) apply (Trunc_functor (-1)).
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
{a : A & r (f a) = y} ->
{z : V & z ∈ set f * (r z = y)}
    intros [a p].
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
{z : V & z ∈ set f * (r z = y)} exists (f a).
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
f a ∈ set f * (r (f a) = y) split.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
f a ∈ set f
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
r (f a) = y
    +
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
f a ∈ set f apply tr; exists a; auto.
    +
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
a: A
p: r (f a) = y
r (f a) = y assumption.
  -
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
hexists (fun z : V => z ∈ set f * (r z = y)) ->
y ∈ set (fun x : A => r (f x)) apply Trunc_rec.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y: V
{z : V & z ∈ set f * (r z = y)} ->
y ∈ set (fun x : A => r (f x))
    intros [z [h p]].
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
y ∈ set (fun x : A => r (f x)) generalize h.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
z ∈ set f -> y ∈ set (fun x : A => r (f x)) apply (Trunc_functor (-1)).
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
{a : A & f a = z} -> {a : A & r (f a) = y}
    intros [a p'].
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
a: A
p': f a = z
{a : A & r (f a) = y} exists a.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
a: A
p': f a = z
r (f a) = y transitivity (r z); auto with path_hints.
ua: Univalence
r: V -> V
A: Type
f: A -> V
y, z: V
h: z ∈ set f
p: r z = y
a: A
p': f a = z
r (f a) = r z exact (ap r p').
Qed.

Lemma separation (C : V -> HProp) : forall a : V,
  hexists (fun w => forall x, x ∈ w <-> x ∈ a * (C x)).
ua: Univalence
C: V -> HProp
forall a : V,
hexists
  (fun w : V => forall x : V, x ∈ w <-> x ∈ a * C x)
Proof.
ua: Univalence
C: V -> HProp
forall a : V,
hexists
  (fun w : V => forall x : V, x ∈ w <-> x ∈ a * C x)
  refine (V_ind_hprop _ _ _).
ua: Univalence
C: V -> HProp
forall (A : Type) (f : A -> V),
(forall a : A,
 hexists
   (fun w : V => forall x : V, x ∈ w <-> x ∈ f a * C x)) ->
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> x ∈ set f * C x)
  intros A f _.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
hexists
  (fun w : V =>
   forall x : V, x ∈ w <-> x ∈ set f * C x) apply tr.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
{w : V & forall x : V, x ∈ w <-> x ∈ set f * C x} exists (set (fun z : {a : A & C (f a)} => f (pr1 z))).
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
forall x : V,
x ∈ set (fun z : {a : A & C (f a)} => f z.1) <->
x ∈ set f * C x split.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
x ∈ set (fun z : {a : A & C (f a)} => f z.1) ->
x ∈ set f * C x
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
x ∈ set f * C x ->
x ∈ set (fun z : {a : A & C (f a)} => f z.1)
  -
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
x ∈ set (fun z : {a : A & C (f a)} => f z.1) ->
x ∈ set f * C x apply Trunc_rec.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
{a : {a : A & C (f a)} & f a.1 = x} -> x ∈ set f * C x
    intros [[a h] p].
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
a: A
h: C (f a)
p: f (a; h).1 = x
x ∈ set f * C x split.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
a: A
h: C (f a)
p: f (a; h).1 = x
x ∈ set f
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
a: A
h: C (f a)
p: f (a; h).1 = x
C x +
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
a: A
h: C (f a)
p: f (a; h).1 = x
x ∈ set f apply tr; exists a; assumption. +
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
a: A
h: C (f a)
p: f (a; h).1 = x
C x exact (transport C p h).
  -
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
x ∈ set f * C x ->
x ∈ set (fun z : {a : A & C (f a)} => f z.1) intros [H1 H2].
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
H1: x ∈ set f
H2: C x
x ∈ set (fun z : {a : A & C (f a)} => f z.1) generalize H1.
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
H1: x ∈ set f
H2: C x
x ∈ set f ->
x ∈ set (fun z : {a : A & C (f a)} => f z.1) apply (Trunc_functor (-1)).
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
H1: x ∈ set f
H2: C x
{a : A & f a = x} ->
{a : {a : A & C (f a)} & f a.1 = x}
    intros [a p].
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
H1: x ∈ set f
H2: C x
a: A
p: f a = x
{a : {a : A & C (f a)} & f a.1 = x} exists (a; transport C p^ H2).
ua: Univalence
C: V -> HProp
A: Type
f: A -> V
x: V
H1: x ∈ set f
H2: C x
a: A
p: f a = x
f (a; transport (fun x : V => C x) p^ H2).1 = x exact p.
Qed.

End AssumingUA.