From HoTT Require Import Basics.From HoTT Require Import Basics.
Require Import Types.Forall Types.Sigma Types.Prod Types.WType.

(** In this file we define indexed W-types. We show that indexed W-types can be reduced to W-types whilst still having definitional computation rules. We also characterize the path space of indexed W-types. This allows us to derive sufficient conditions for an indexed W-type to be truncated. *)

(** This is mostly adapted from Jasper Hugunin's formalization in Coq: https://github.com/jashug/IWTypes *)

(** On a more meta-theoretic note, this partly justifies the use of indexed inductive types in Coq with respect to homotopy type theory. *)

Inductive IW
  (I : Type) (** The indexing type *)
  (A : Type) (** The type of labels / constructors / data *)
  (B : A -> Type) (** The type of arities / arguments / children *)
  (i : A -> I) (** The index map (for labels) *)
  (j : forall x, B x -> I) (** The index map for arguments *)
  : I -> Type :=
| iw_sup (x : A)
    : (forall (y : B x), IW I A B i j (j x y)) -> IW I A B i j (i x).

Definition iw_label {A B I i j} {l : I} (w : IW I A B i j l) : A :=
  match w with
  | iw_sup x y => x
  end.

Definition iw_arity {A B I i j} (l : I) (w : IW I A B i j l)
  : forall (y : B (iw_label w)), IW I A B i j (j (iw_label w) y) :=
  match w with
  | iw_sup x y => y
  end.

Definition path_index_iw_label {A B I i j} (l : I) (w : IW I A B i j l)
  : i (iw_label w) = l.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
i (iw_label w) = l
Proof.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
i (iw_label w) = l
  by destruct w.
Defined.

Definition iw_eta {A B I i j} (l : I) (w : IW I A B i j l)
  : path_index_iw_label l w # iw_sup I A B i j (iw_label w) (iw_arity l w) = w.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
transport (IW I A B i j) (path_index_iw_label l w)
  (iw_sup I A B i j (iw_label w) (iw_arity l w)) =
w
Proof.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
transport (IW I A B i j) (path_index_iw_label l w)
  (iw_sup I A B i j (iw_label w) (iw_arity l w)) =
w
  by destruct w.
Defined.

(** We have a canonical map from the IW-type to the fiber of the index map *)
Definition iw_to_hfiber_index {A B I i j} (l : I) : IW I A B i j l -> hfiber i l.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
IW I A B i j l -> hfiber i l
Proof.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
IW I A B i j l -> hfiber i l
  intros w.
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
hfiber i l
  exists (iw_label w).
A: Type
B: A -> Type
I: Type
i: A -> I
j: forall x : A, B x -> I
l: I
w: IW I A B i j l
i (iw_label w) = l
  apply path_index_iw_label.
Defined.

Definition pointwise_paths_ind `{Funext} {A : Type} {B : A -> Type}
  (a : forall x, B x)
  (P : forall b, a == b -> Type)
  (f : P a (fun _ => 1%path))
  {b : forall x, B x} (p : a == b)
  : P b p.
H: Funext
A: Type
B: A -> Type
a: forall x : A, B x
P: forall b0 : forall x : A, B x, a == b0 -> Type
f: P a (fun x : A => 1)
b: forall x : A, B x
p: a == b
P b p
Proof.
H: Funext
A: Type
B: A -> Type
a: forall x : A, B x
P: forall b0 : forall x : A, B x, a == b0 -> Type
f: P a (fun x : A => 1)
b: forall x : A, B x
p: a == b
P b p
  refine (equiv_ind apD10 (P b) _ p).
H: Funext
A: Type
B: A -> Type
a: forall x : A, B x
P: forall b0 : forall x : A, B x, a == b0 -> Type
f: P a (fun x : A => 1)
b: forall x : A, B x
p: a == b
forall x : a = b, P b (apD10 x)
  intros [].
H: Funext
A: Type
B: A -> Type
a: forall x : A, B x
P: forall b0 : forall x : A, B x, a == b0 -> Type
f: P a (fun x : A => 1)
b: forall x : A, B x
p: a == b
P a (apD10 1)
  exact f.
Defined.

(** * Reduction of indexed W-types to W-types *)

(** Jasper Hugunin found this construction (typecheck un-indexed trees) in "Indexed Containers by Thorsten Altenkirch and Peter Morris". http://www.cs.nott.ac.uk/~psztxa/publ/ICont.pdf
This references the following:
  * M. Abbott, T. Altenkirch, and N. Ghani. Containers - constructing strictly positive types. Theoretical Computer Science, 342:327, September 2005. Applied Semantics: Selected Topics.
  * N. Gambino and M. Hyland. Well-founded trees and dependent polynomial functors. In S. Berardi, M. Coppo, and F. Damiani, editors, types for Proofs and Programs (TYPES 2003), Lecture Notes in Computer Science, 2004
as previous examples of the technique. *)

Section Reduction.

  Context (I : Type) (A : Type) (B : A -> Type)
    (i : A -> I) (j : forall x, B x -> I).

  Fixpoint IsIndexedBy (x : I) (w : W A B) : Type :=
    match w with
    | w_sup a b => (i a = x) * (forall c, IsIndexedBy (j a c) (b c))
    end.

  Definition IW' (x : I) := sig (IsIndexedBy x).

  Definition iw_sup' (x : A) (y : forall z : B x, IW' (j x z)) : IW' (i x)
    := (w_sup A B x (fun a => pr1 (y a)); (idpath, (fun a => pr2 (y a)))).

  (** We can derive the induction principle for IW-types *)
  Definition IW'_ind (P : forall i, IW' i -> Type)
    (S : forall x y, (forall c, P _ (y c)) -> P _ (iw_sup' x y))
    : forall x w, P x w.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
forall (x : I) (w : IW' x), P x w
  Proof.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
forall (x : I) (w : IW' x), P x w
    intros x [w r].
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x0 : A) (y : forall x1 : B x0, IW' (j x0 x1)),
(forall c : B x0, P (j x0 c) (y c)) -> P (i x0) (iw_sup' x0 y)
x: I
w: W A B
r: IsIndexedBy x w
P x (w; r)
    revert w x r.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
forall (w : W A B) (x : I) (r : IsIndexedBy x w), P x (w; r)
    induction w as [a b k].
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
a: A
b: B a -> W A B
k: forall (b0 : B a) (x : I) (r : IsIndexedBy x (b b0)), P x (b b0; r)
forall (x : I) (r : IsIndexedBy x (w_sup A B a b)), P x (w_sup A B a b; r)
    intros x [p IH].
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x0 : A) (y : forall x1 : B x0, IW' (j x0 x1)),
(forall c : B x0, P (j x0 c) (y c)) -> P (i x0) (iw_sup' x0 y)
a: A
b: B a -> W A B
k: forall (b0 : B a) (x0 : I) (r : IsIndexedBy x0 (b b0)), P x0 (b b0; r)
x: I
p: i a = x
IH: forall c : B a, IsIndexedBy (j a c) (b c)
P x (w_sup A B a b; (p, IH))
    destruct p.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
a: A
b: B a -> W A B
k: forall (b0 : B a) (x : I) (r : IsIndexedBy x (b b0)), P x (b b0; r)
IH: forall c : B a, IsIndexedBy (j a c) (b c)
P (i a) (w_sup A B a b; (1, IH))
    refine (S a (fun c => (b c; IH c)) _).
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B x, P (j x c) (y c)) -> P (i x) (iw_sup' x y)
a: A
b: B a -> W A B
k: forall (b0 : B a) (x : I) (r : IsIndexedBy x (b b0)), P x (b b0; r)
IH: forall c : B a, IsIndexedBy (j a c) (b c)
forall c : B a, P (j a c) (b c; IH c)
    intros c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
P: forall i0 : I, IW' i0 -> Type
S: forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c0 : B x, P (j x c0) (y c0)) -> P (i x) (iw_sup' x y)
a: A
b: B a -> W A B
k: forall (b0 : B a) (x : I) (r : IsIndexedBy x (b b0)), P x (b b0; r)
IH: forall c0 : B a, IsIndexedBy (j a c0) (b c0)
c: B a
P (j a c) (b c; IH c)
    apply k.
  Defined.

  (** We have definitional computation rules for this eliminator. *)
  Definition IW'_ind_beta_iw_sup' (P : forall i, IW' i -> Type)
    (S : forall x y, (forall c, P _ (y c)) -> P _ (iw_sup' x y)) x y
    : IW'_ind P S _ (iw_sup' x y) = S x y (fun c => IW'_ind P S _ (y c))
    := idpath.

  (** Showing that IW-types are equivalent to W-types requires funext. *)
  Definition equiv_wtype_iwtype `{Funext} (x : I)
    : IW' x <~> IW I A B i j x.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW' x <~> IW I A B i j x
  Proof.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW' x <~> IW I A B i j x
    snapply equiv_adjointify.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW' x -> IW I A B i j x
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW I A B i j x -> IW' x
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
?f o ?g == idmap
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
?g o ?f == idmap
    {
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW' x -> IW I A B i j x rapply (IW'_ind (fun l _ => IW I A B i j l)).
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
forall x0 : A,
(forall x1 : B x0, IW' (j x0 x1)) ->
(forall c : B x0, IW I A B i j (j x0 c)) -> IW I A B i j (i x0)
      intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a, IW I A B i j (j a c0)
IW I A B i j (i a)
      apply iw_sup.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a, IW I A B i j (j a c0)
forall y : B a, IW I A B i j (j a y)
      intros y.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a, IW I A B i j (j a c0)
y: B a
IW I A B i j (j a y)
      apply c. }
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW I A B i j x -> IW' x
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
     (c : forall c : B a, IW I A B i j (j a c)) =>
   iw_sup I A B i j a (fun y : B a => c y))
  x
o ?g == idmap
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
?g
o IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
    (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
       (c : forall c : B a, IW I A B i j (j a c)) =>
     iw_sup I A B i j a (fun y : B a => c y))
    x ==
idmap
    {
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW I A B i j x -> IW' x rapply (IW_rect I A B i j (fun l _ => IW' l)).
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
forall x0 : A,
(forall y : B x0, IW I A B i j (j x0 y)) ->
(forall y : B x0, IW' (j x0 y)) -> IW' (i x0)
      intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y : B a, IW I A B i j (j a y)
c: forall y : B a, IW' (j a y)
IW' (i a)
      apply iw_sup'.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y : B a, IW I A B i j (j a y)
c: forall y : B a, IW' (j a y)
forall z : B a, IW' (j a z)
      intros y.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y0 : B a, IW I A B i j (j a y0)
c: forall y0 : B a, IW' (j a y0)
y: B a
IW' (j a y)
      apply c. }
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
     (c : forall c : B a, IW I A B i j (j a c)) =>
   iw_sup I A B i j a (fun y : B a => c y))
  x
o IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
    (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
       (c : forall y : B a, IW' (j a y)) =>
     iw_sup' a (fun y : B a => c y))
    x ==
idmap
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
     (c : forall y : B a, IW' (j a y)) =>
   iw_sup' a (fun y : B a => c y))
  x
o IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
    (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
       (c : forall c : B a, IW I A B i j (j a c)) =>
     iw_sup I A B i j a (fun y : B a => c y))
    x ==
idmap
    {
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
     (c : forall c : B a, IW I A B i j (j a c)) =>
   iw_sup I A B i j a (fun y : B a => c y))
  x
o IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
    (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
       (c : forall y : B a, IW' (j a y)) =>
     iw_sup' a (fun y : B a => c y))
    x ==
idmap rapply (IW_rect I A B i j (fun x y => IW'_ind _ _ x _ = y)).
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
forall (x0 : A) (i0 : forall y : B x0, IW I A B i j (j x0 y)),
(forall y : B x0,
 IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
   (fun (a : A) (_ : forall x1 : B a, IW' (j a x1))
      (c : forall c : B a, IW I A B i j (j a c)) =>
    iw_sup I A B i j a (fun y0 : B a => c y0))
   (j x0 y)
   (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
      (fun (a : A) (_ : forall y0 : B a, IW I A B i j (j a y0))
         (c : forall y0 : B a, IW' (j a y0)) =>
       iw_sup' a (fun y0 : B a => c y0))
      (j x0 y) (i0 y)) =
 i0 y) ->
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a : A) (_ : forall x1 : B a, IW' (j a x1))
     (c : forall c : B a, IW I A B i j (j a c)) =>
   iw_sup I A B i j a (fun y : B a => c y))
  (i x0)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
        (c : forall y : B a, IW' (j a y)) =>
      iw_sup' a (fun y : B a => c y))
     (i x0) (iw_sup I A B i j x0 i0)) =
iw_sup I A B i j x0 i0
      cbn; intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y : B a, IW I A B i j (j a y)
c: forall y : B a,
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
     (c0 : forall c0 : B a0, IW I A B i j (j a0 c0)) =>
   iw_sup I A B i j a0 (fun y0 : B a0 => c0 y0))
  (j a y)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
        (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
      iw_sup' a0 (fun y0 : B a0 => c0 y0))
     (j a y) (b y)) =
b y
iw_sup I A B i j a
  (fun y : B a =>
   W_rect A B
     (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
     (fun (a0 : A) (b0 : B a0 -> W A B)
        (k : forall (b1 : B a0) (x0 : I),
             IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
        (x0 : I)
        (r : (i a0 = x0) * (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
      match fst r in (_ = i0) return (IW I A B i j i0) with
      | 1 => iw_sup I A B i j a0 (fun y0 : B a0 => k y0 (j a0 y0) (snd r y0))
      end)
     (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
        (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
           (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
         iw_sup' a0 (fun y0 : B a0 => c0 y0))
        (j a y) (b y)).1
     (j a y)
     (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
        (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
           (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
         iw_sup' a0 (fun y0 : B a0 => c0 y0))
        (j a y) (b y)).2) =
iw_sup I A B i j a b
      apply ap.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y : B a, IW I A B i j (j a y)
c: forall y : B a,
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
     (c0 : forall c0 : B a0, IW I A B i j (j a0 c0)) =>
   iw_sup I A B i j a0 (fun y0 : B a0 => c0 y0))
  (j a y)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
        (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
      iw_sup' a0 (fun y0 : B a0 => c0 y0))
     (j a y) (b y)) =
b y
(fun y : B a =>
 W_rect A B
   (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
   (fun (a0 : A) (b0 : B a0 -> W A B)
      (k : forall (b1 : B a0) (x0 : I),
           IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
      (x0 : I)
      (r : (i a0 = x0) * (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
    match fst r in (_ = i0) return (IW I A B i j i0) with
    | 1 => iw_sup I A B i j a0 (fun y0 : B a0 => k y0 (j a0 y0) (snd r y0))
    end)
   (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
      (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
         (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
       iw_sup' a0 (fun y0 : B a0 => c0 y0))
      (j a y) (b y)).1
   (j a y)
   (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
      (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
         (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
       iw_sup' a0 (fun y0 : B a0 => c0 y0))
      (j a y) (b y)).2) =
b
      funext y.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
a: A
b: forall y0 : B a, IW I A B i j (j a y0)
c: forall y0 : B a,
IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
  (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
     (c0 : forall c0 : B a0, IW I A B i j (j a0 c0)) =>
   iw_sup I A B i j a0 (fun y1 : B a0 => c0 y1))
  (j a y0)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y1 : B a0, IW I A B i j (j a0 y1))
        (c0 : forall y1 : B a0, IW' (j a0 y1)) =>
      iw_sup' a0 (fun y1 : B a0 => c0 y1))
     (j a y0) (b y0)) =
b y0
y: B a
W_rect A B
  (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
  (fun (a0 : A) (b0 : B a0 -> W A B)
     (k : forall (b1 : B a0) (x0 : I),
          IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
     (x0 : I)
     (r : (i a0 = x0) * (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
   match fst r in (_ = i0) return (IW I A B i j i0) with
   | 1 => iw_sup I A B i j a0 (fun y0 : B a0 => k y0 (j a0 y0) (snd r y0))
   end)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
        (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
      iw_sup' a0 (fun y0 : B a0 => c0 y0))
     (j a y) (b y)).1
  (j a y)
  (IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
        (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
      iw_sup' a0 (fun y0 : B a0 => c0 y0))
     (j a y) (b y)).2 =
b y
      apply c. }
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
     (c : forall y : B a, IW' (j a y)) =>
   iw_sup' a (fun y : B a => c y))
  x
o IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
    (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
       (c : forall c : B a, IW I A B i j (j a c)) =>
     iw_sup I A B i j a (fun y : B a => c y))
    x ==
idmap
    simpl.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
(fun x0 : IW' x =>
 IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
   (fun (a : A) (_ : forall y : B a, IW I A B i j (j a y))
      (c : forall y : B a, IW' (j a y)) =>
    iw_sup' a (fun y : B a => c y))
   x
   (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
      (fun (a : A) (_ : forall x1 : B a, IW' (j a x1))
         (c : forall c : B a, IW I A B i j (j a c)) =>
       iw_sup I A B i j a (fun y : B a => c y))
      x x0)) ==
idmap
    intro y.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
y: IW' x
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a : A) (_ : forall y0 : B a, IW I A B i j (j a y0))
     (c : forall y0 : B a, IW' (j a y0)) =>
   iw_sup' a (fun y0 : B a => c y0))
  x
  (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
     (fun (a : A) (_ : forall x0 : B a, IW' (j a x0))
        (c : forall c : B a, IW I A B i j (j a c)) =>
      iw_sup I A B i j a (fun y0 : B a => c y0))
     x y) =
y
    rapply (IW'_ind (fun x y => IW_rect I A B i j _ _ x _ = y)).
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
y: IW' x
forall (x0 : A) (y0 : forall x1 : B x0, IW' (j x0 x1)),
(forall c : B x0,
 IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
   (fun (a : A) (_ : forall y1 : B a, IW I A B i j (j a y1))
      (c0 : forall y1 : B a, IW' (j a y1)) =>
    iw_sup' a (fun y1 : B a => c0 y1))
   (j x0 c)
   (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
      (fun (a : A) (_ : forall x1 : B a, IW' (j a x1))
         (c0 : forall c0 : B a, IW I A B i j (j a c0)) =>
       iw_sup I A B i j a (fun y1 : B a => c0 y1))
      (j x0 c) (y0 c)) =
 y0 c) ->
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a : A) (_ : forall y1 : B a, IW I A B i j (j a y1))
     (c : forall y1 : B a, IW' (j a y1)) =>
   iw_sup' a (fun y1 : B a => c y1))
  (i x0)
  (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
     (fun (a : A) (_ : forall x1 : B a, IW' (j a x1))
        (c : forall c : B a, IW I A B i j (j a c)) =>
      iw_sup I A B i j a (fun y1 : B a => c y1))
     (i x0) (iw_sup' x0 y0)) =
iw_sup' x0 y0
    cbn; intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a,
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
     (c1 : forall y0 : B a0, IW' (j a0 y0)) =>
   iw_sup' a0 (fun y0 : B a0 => c1 y0))
  (j a c0)
  (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
     (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
        (c1 : forall c1 : B a0, IW I A B i j (j a0 c1)) =>
      iw_sup I A B i j a0 (fun y0 : B a0 => c1 y0))
     (j a c0) (b c0)) =
b c0
iw_sup' a
  (fun y0 : B a =>
   IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
     (fun (a0 : A) (_ : forall y1 : B a0, IW I A B i j (j a0 y1))
        (c0 : forall y1 : B a0, IW' (j a0 y1)) =>
      iw_sup' a0 (fun y1 : B a0 => c0 y1))
     (j a y0)
     (W_rect A B
        (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
        (fun (a0 : A) (b0 : B a0 -> W A B)
           (k : forall (b1 : B a0) (x0 : I),
                IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
           (x0 : I)
           (r : (i a0 = x0) *
                (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
         match fst r in (_ = i0) return (IW I A B i j i0) with
         | 1 =>
             iw_sup I A B i j a0 (fun y1 : B a0 => k y1 (j a0 y1) (snd r y1))
         end)
        (b y0).1 (j a y0) (b y0).2)) =
iw_sup' a b
    apply ap.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a,
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
     (c1 : forall y0 : B a0, IW' (j a0 y0)) =>
   iw_sup' a0 (fun y0 : B a0 => c1 y0))
  (j a c0)
  (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
     (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
        (c1 : forall c1 : B a0, IW I A B i j (j a0 c1)) =>
      iw_sup I A B i j a0 (fun y0 : B a0 => c1 y0))
     (j a c0) (b c0)) =
b c0
(fun y0 : B a =>
 IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
   (fun (a0 : A) (_ : forall y1 : B a0, IW I A B i j (j a0 y1))
      (c0 : forall y1 : B a0, IW' (j a0 y1)) =>
    iw_sup' a0 (fun y1 : B a0 => c0 y1))
   (j a y0)
   (W_rect A B
      (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
      (fun (a0 : A) (b0 : B a0 -> W A B)
         (k : forall (b1 : B a0) (x0 : I),
              IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
         (x0 : I)
         (r : (i a0 = x0) * (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
       match fst r in (_ = i0) return (IW I A B i j i0) with
       | 1 =>
           iw_sup I A B i j a0 (fun y1 : B a0 => k y1 (j a0 y1) (snd r y1))
       end)
      (b y0).1 (j a y0) (b y0).2)) =
b
    funext d.
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c0 : B a,
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
     (c1 : forall y0 : B a0, IW' (j a0 y0)) =>
   iw_sup' a0 (fun y0 : B a0 => c1 y0))
  (j a c0)
  (IW'_ind (fun (l : I) (_ : IW' l) => IW I A B i j l)
     (fun (a0 : A) (_ : forall x0 : B a0, IW' (j a0 x0))
        (c1 : forall c1 : B a0, IW I A B i j (j a0 c1)) =>
      iw_sup I A B i j a0 (fun y0 : B a0 => c1 y0))
     (j a c0) (b c0)) =
b c0
d: B a
IW_rect I A B i j (fun (l : I) (_ : IW I A B i j l) => IW' l)
  (fun (a0 : A) (_ : forall y0 : B a0, IW I A B i j (j a0 y0))
     (c0 : forall y0 : B a0, IW' (j a0 y0)) =>
   iw_sup' a0 (fun y0 : B a0 => c0 y0))
  (j a d)
  (W_rect A B
     (fun w : W A B => forall x0 : I, IsIndexedBy x0 w -> IW I A B i j x0)
     (fun (a0 : A) (b0 : B a0 -> W A B)
        (k : forall (b1 : B a0) (x0 : I),
             IsIndexedBy x0 (b0 b1) -> IW I A B i j x0)
        (x0 : I)
        (r : (i a0 = x0) * (forall c0 : B a0, IsIndexedBy (j a0 c0) (b0 c0))) =>
      match fst r in (_ = i0) return (IW I A B i j i0) with
      | 1 => iw_sup I A B i j a0 (fun y0 : B a0 => k y0 (j a0 y0) (snd r y0))
      end)
     (b d).1 (j a d) (b d).2) =
b d
    apply c.
  Defined.

End Reduction.

(** * Characterization of path types of IW-types. Argument due to Jasper Hugunin. *)

Section Paths.

  Context `{Funext}
    (I : Type) (A : Type) (B : A -> Type)
    (i : A -> I) (j : forall x, B x -> I).

  (** We wish to show that path types of IW-types are IW-types themselves. We do this by showing the path type satisfies the same induction principle as the IW-type hence they are equivalent. *)

  Let I' : Type := {k : I & IW I A B i j k * IW I A B i j k}.
  Let A' : Type := {e : A & (forall c, IW I A B i j (j e c)) * (forall c, IW I A B i j (j e c))}.
  Let B' : A' -> Type := fun X => B X.1.
  Let i' : A' -> I' := functor_sigma i (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)).
  Let j' : forall k, B' k -> I' := fun k c => (j k.1 c; (fst k.2 c, snd k.2 c)).

  Let IWPath : I' -> Type := fun x => fst (pr2 x) = snd (pr2 x).

  Definition iwpath_sup (x : A')
    : (forall y : B' x, IWPath (j' x y)) -> IWPath (i' x).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A'
(forall y : B' x, IWPath (j' x y)) -> IWPath (i' x)
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A'
(forall y : B' x, IWPath (j' x y)) -> IWPath (i' x)
    destruct x as [x [c1 c2]].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
(forall y : B' (x; (c1, c2)), IWPath (j' (x; (c1, c2)) y)) ->
IWPath (i' (x; (c1, c2)))
    intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y0 : B' (x; (c1, c2)), IWPath (j' (x; (c1, c2)) y0)
IWPath (i' (x; (c1, c2)))
    unfold IWPath.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y0 : B' (x; (c1, c2)), IWPath (j' (x; (c1, c2)) y0)
fst (i' (x; (c1, c2))).2 = snd (i' (x; (c1, c2))).2
    cbn; apply ap.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y0 : B' (x; (c1, c2)), IWPath (j' (x; (c1, c2)) y0)
c1 = c2
    funext l.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y0 : B' (x; (c1, c2)), IWPath (j' (x; (c1, c2)) y0)
l: B x
c1 l = c2 l
    apply y.
  Defined.

  Definition iwpath_sup_refl (x : A) (a : forall c : B x, IW I A B i j (j x c))
    : iwpath_sup (x; (a, a)) (apD10 1) = idpath.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a: forall c : B x, IW I A B i j (j x c)
iwpath_sup (x; (a, a)) (apD10 1) = 1
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a: forall c : B x, IW I A B i j (j x c)
iwpath_sup (x; (a, a)) (apD10 1) = 1
    unfold iwpath_sup.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a: forall c : B x, IW I A B i j (j x c)
ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => apD10 1 l)) = 1
    rewrite path_forall_1.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a: forall c : B x, IW I A B i j (j x c)
ap (iw_sup I A B i j x) 1 = 1
    reflexivity.
  Defined.

  Section Ind.

    Context
      (P : forall xab, IWPath xab -> Type)
      (S : forall a b, (forall c, P _ (b c)) -> P (i' a) (iwpath_sup a b)).

    Definition IWPath_ind_refl : forall l a, P (l ; (a, a)) idpath.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x : B' a, IWPath (j' a x)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
forall (l : I) (a : IW I A B i j l), P (l; (a, a)) 1
    Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x : B' a, IWPath (j' a x)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
forall (l : I) (a : IW I A B i j l), P (l; (a, a)) 1
      rapply (IW_rect I A B i j (fun l a => P (l; (a, a)) idpath)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x : B' a, IWPath (j' a x)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
forall (x : A) (i0 : forall y : B x, IW I A B i j (j x y)),
(forall y : B x, P (j x y; (i0 y, i0 y)) 1) ->
P (i x; (iw_sup I A B i j x i0, iw_sup I A B i j x i0)) 1
      intros x a q.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x a)) 1
      pose (S (x; (a, a)) _ q) as p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
p:= S (x; (a, a)) (fun y : B x => 1) q: P (i' (x; (a, a))) (iwpath_sup (x; (a, a)) (fun y : B x => 1))
P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x a)) 1
      unfold iwpath_sup in p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
p:= S (x; (a, a)) (fun y : B x => 1) q: P (i' (x; (a, a)))
  (ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => 1)))
P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x a)) 1
      refine (transport (P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x a))) _ p).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
p:= S (x; (a, a)) (fun y : B x => 1) q: P (i' (x; (a, a)))
  (ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => 1)))
ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => 1)) = 1
      change (ap (iw_sup I A B i j x) (path_forall a a (apD10 idpath))
        = ap (iw_sup I A B i j x) 1%path).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
p:= S (x; (a, a)) (fun y : B x => 1) q: P (i' (x; (a, a)))
  (ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => 1)))
ap (iw_sup I A B i j x) (path_forall a a (apD10 1)) =
ap (iw_sup I A B i j x) 1
      refine (ap _ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: A
a: forall y : B x, IW I A B i j (j x y)
q: forall y : B x, P (j x y; (a y, a y)) 1
p:= S (x; (a, a)) (fun y : B x => 1) q: P (i' (x; (a, a)))
  (ap (iw_sup I A B i j x) (path_forall a a (fun l : B x => 1)))
path_forall a a (apD10 1) = 1
      apply eissect.
    Defined.

    Definition IWPath_ind : forall x p, P x p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x : B' a, IWPath (j' a x)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
forall (x : I') (p : IWPath x), P x p
    Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x : B' a, IWPath (j' a x)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
forall (x : I') (p : IWPath x), P x p
      intros [x [a b]].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: I
a, b: IW I A B i j x
forall p : IWPath (x; (a, b)), P (x; (a, b)) p
      unfold IWPath; cbn.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: I
a, b: IW I A B i j x
forall p : a = b, P (x; (a, b)) p
      destruct p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b c)) -> P (i' a0) (iwpath_sup a0 b)
x: I
a: IW I A B i j x
P (x; (a, a)) 1
      apply IWPath_ind_refl.
    Defined.

    (** The computation rule for the induction principle. *)
    Definition IWPath_ind_beta_iwpath_sup (x : A') (h : forall y : B' x, IWPath (j' x y))
      : IWPath_ind _ (iwpath_sup x h)
        = S x h (fun c => IWPath_ind _ (h c)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x0 : B' a, IWPath (j' a x0)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
x: A'
h: forall y : B' x, IWPath (j' x y)
IWPath_ind (i' x) (iwpath_sup x h) =
S x h (fun c : B' x => IWPath_ind (j' x c) (h c))
    Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a : A') (b : forall x0 : B' a, IWPath (j' a x0)),
(forall c : B' a, P (j' a c) (b c)) -> P (i' a) (iwpath_sup a b)
x: A'
h: forall y : B' x, IWPath (j' x y)
IWPath_ind (i' x) (iwpath_sup x h) =
S x h (fun c : B' x => IWPath_ind (j' x c) (h c))
      destruct x as [x [a b]].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B' (x; (a, b)), IWPath (j' (x; (a, b)) y)
IWPath_ind (i' (x; (a, b))) (iwpath_sup (x; (a, b)) h) =
S (x; (a, b)) h
  (fun c : B' (x; (a, b)) => IWPath_ind (j' (x; (a, b)) c) (h c))
      cbv in h.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
IWPath_ind (i' (x; (a, b))) (iwpath_sup (x; (a, b)) h) =
S (x; (a, b)) h
  (fun c : B' (x; (a, b)) => IWPath_ind (j' (x; (a, b)) c) (h c))
      refine (_ @ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
IWPath_ind (i' (x; (a, b))) (iwpath_sup (x; (a, b)) h) = ?Goal
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
?Goal =
S (x; (a, b)) h
  (fun c : B' (x; (a, b)) => IWPath_ind (j' (x; (a, b)) c) (h c))
      {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
IWPath_ind (i' (x; (a, b))) (iwpath_sup (x; (a, b)) h) = ?Goal refine (_ @ ap _ (eisadj (path_forall _ _) h)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
IWPath_ind (i' (x; (a, b))) (iwpath_sup (x; (a, b)) h) =
?Goal1 (eisretr (path_forall a b) (path_forall a b h))
        refine (paths_ind _
          (fun b p' =>
            paths_ind _ (fun r p'' => P (i x ; (iw_sup I A B i j x a , r)) p'')
              (IWPath_ind_refl (i x) (iw_sup I A B i j x a))
              _ (ap (iw_sup I A B i j x) p')
            = paths_rec (path_forall _ _ (apD10 p'))
                (fun p'' => P (_ ; (_, _)) (ap (iw_sup I A B i j x) p''))
                (S (x ; (a, b)) (apD10 p')
                (fun c => IWPath_ind (_ ; (_, _)) (apD10 p' c)))
                p' (eissect apD10 p'))
          _ _ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
paths_ind (iw_sup I A B i j x a)
  (fun (r : IW I A B i j (i x)) (p'' : iw_sup I A B i j x a = r) =>
   P (i x; (iw_sup I A B i j x a, r)) p'')
  (IWPath_ind_refl (i x) (iw_sup I A B i j x a)) (iw_sup I A B i j x a)
  (ap (iw_sup I A B i j x) 1) =
paths_rec (path_forall a a (apD10 1))
  (fun p'' : a = a =>
   P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x a))
     (ap (iw_sup I A B i j x) p''))
  (S (x; (a, a)) (apD10 1)
     (fun c : B' (x; (a, a)) => IWPath_ind (j x c; (a c, a c)) (apD10 1 c)))
  1 (eissect apD10 1)
        exact (transport_compose _ _ _ _)^. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall xab : I', IWPath xab -> Type
S: forall (a0 : A') (b0 : forall x0 : B' a0, IWPath (j' a0 x0)),
(forall c : B' a0, P (j' a0 c) (b0 c)) -> P (i' a0) (iwpath_sup a0 b0)
x: A
a, b: forall c : B x, IW I A B i j (j x c)
h: forall y : B x, a y = b y
paths_rec
  (path_forall a (snd (x; (a, b)).2)
     (apD10
        (path_forall (fst (x; (a, b)).2) (snd (x; (a, b)).2)
           ((fun l : B (x; (a, b)).1 => h l)
            :
            fst (x; (a, b)).2 == snd (x; (a, b)).2))))
  (fun p'' : a = snd (x; (a, b)).2 =>
   P (i x; (iw_sup I A B i j x a, iw_sup I A B i j x (snd (x; (a, b)).2)))
     (ap (iw_sup I A B i j x) p''))
  (S (x; (a, snd (x; (a, b)).2))
     (apD10
        (path_forall (fst (x; (a, b)).2) (snd (x; (a, b)).2)
           ((fun l : B (x; (a, b)).1 => h l)
            :
            fst (x; (a, b)).2 == snd (x; (a, b)).2)))
     (fun c : B' (x; (a, snd (x; (a, b)).2)) =>
      IWPath_ind (j x c; (a c, snd (x; (a, b)).2 c))
        (apD10
           (path_forall (fst (x; (a, b)).2) (snd (x; (a, b)).2)
              ((fun l : B (x; (a, b)).1 => h l)
               :
               fst (x; (a, b)).2 == snd (x; (a, b)).2))
           c)))
  (path_forall (fst (x; (a, b)).2) (snd (x; (a, b)).2)
     ((fun l : B (x; (a, b)).1 => h l)
      :
      fst (x; (a, b)).2 == snd (x; (a, b)).2))
  (ap (path_forall a b) (eissect (path_forall a b) h)) =
S (x; (a, b)) h
  (fun c : B' (x; (a, b)) => IWPath_ind (j' (x; (a, b)) c) (h c))
      by cbn; destruct (eisretr apD10 h).
    Defined.

  End Ind.

  (** The path type of an IW-type is again an IW-type. *)
  Definition equiv_path_iwtype (x : I) (a b : IW I A B i j x)
    : IW I' A' B' i' j' (x; (a, b)) <~> a = b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IW I' A' B' i' j' (x; (a, b)) <~> a = b
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IW I' A' B' i' j' (x; (a, b)) <~> a = b
    change (IW I' A' B' i' j' (x; (a, b)) <~> IWPath (x; (a,b))).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IW I' A' B' i' j' (x; (a, b)) <~> IWPath (x; (a, b))
    snapply equiv_adjointify.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IW I' A' B' i' j' (x; (a, b)) -> IWPath (x; (a, b))
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IWPath (x; (a, b)) -> IW I' A' B' i' j' (x; (a, b))
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
?f o ?g == idmap
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
?g o ?f == idmap
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IW I' A' B' i' j' (x; (a, b)) -> IWPath (x; (a, b)) intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
y: IW I' A' B' i' j' (x; (a, b))
IWPath (x; (a, b))
      induction y as [e f g].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y : B' e, IW I' A' B' i' j' (j' e y)
g: forall y : B' e, IWPath (j' e y)
IWPath (i' e)
      apply iwpath_sup.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y : B' e, IW I' A' B' i' j' (j' e y)
g: forall y : B' e, IWPath (j' e y)
forall y : B' e, IWPath (j' e y)
      intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y0 : B' e, IW I' A' B' i' j' (j' e y0)
g: forall y0 : B' e, IWPath (j' e y0)
y: B' e
IWPath (j' e y)
      apply g. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IWPath (x; (a, b)) -> IW I' A' B' i' j' (x; (a, b))
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
(fun y : IW I' A' B' i' j' (x; (a, b)) =>
 let s := (x; (a, b)) in
 IW_rect I' A' B' i' j'
   (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
   (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
      (g : forall y0 : B' e, IWPath (j' e y0)) =>
    iwpath_sup e (fun y0 : B' e => g y0))
   s y)
o ?g == idmap
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
?g
o (fun y : IW I' A' B' i' j' (x; (a, b)) =>
   let s := (x; (a, b)) in
   IW_rect I' A' B' i' j'
     (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
     (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
        (g : forall y0 : B' e, IWPath (j' e y0)) =>
      iwpath_sup e (fun y0 : B' e => g y0))
     s y) ==
idmap
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
IWPath (x; (a, b)) -> IW I' A' B' i' j' (x; (a, b)) intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
y: IWPath (x; (a, b))
IW I' A' B' i' j' (x; (a, b))
      induction y as [e f g] using IWPath_ind.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall x0 : B' e, IWPath (j' e x0)
g: forall c : B' e, IW I' A' B' i' j' (j' e c)
IW I' A' B' i' j' (i' e)
      apply iw_sup.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall x0 : B' e, IWPath (j' e x0)
g: forall c : B' e, IW I' A' B' i' j' (j' e c)
forall y : B' e, IW I' A' B' i' j' (j' e y)
      intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall x0 : B' e, IWPath (j' e x0)
g: forall c : B' e, IW I' A' B' i' j' (j' e c)
y: B' e
IW I' A' B' i' j' (j' e y)
      apply g. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
(fun y : IW I' A' B' i' j' (x; (a, b)) =>
 let s := (x; (a, b)) in
 IW_rect I' A' B' i' j'
   (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
   (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
      (g : forall y0 : B' e, IWPath (j' e y0)) =>
    iwpath_sup e (fun y0 : B' e => g y0))
   s y)
o (fun y : IWPath (x; (a, b)) =>
   let s := (x; (a, b)) in
   IWPath_ind (fun (s0 : I') (_ : IWPath s0) => IW I' A' B' i' j' s0)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
      iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
     s y) ==
idmap
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
(fun y : IWPath (x; (a, b)) =>
 let s := (x; (a, b)) in
 IWPath_ind (fun (s0 : I') (_ : IWPath s0) => IW I' A' B' i' j' s0)
   (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
      (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
    iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
   s y)
o (fun y : IW I' A' B' i' j' (x; (a, b)) =>
   let s := (x; (a, b)) in
   IW_rect I' A' B' i' j'
     (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
     (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
        (g : forall y0 : B' e, IWPath (j' e y0)) =>
      iwpath_sup e (fun y0 : B' e => g y0))
     s y) ==
idmap
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
(fun y : IW I' A' B' i' j' (x; (a, b)) =>
 let s := (x; (a, b)) in
 IW_rect I' A' B' i' j'
   (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
   (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
      (g : forall y0 : B' e, IWPath (j' e y0)) =>
    iwpath_sup e (fun y0 : B' e => g y0))
   s y)
o (fun y : IWPath (x; (a, b)) =>
   let s := (x; (a, b)) in
   IWPath_ind (fun (s0 : I') (_ : IWPath s0) => IW I' A' B' i' j' s0)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
      iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
     s y) ==
idmap intros y; cbn.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
y: IWPath (x; (a, b))
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
     (g : forall y0 : B' e, IWPath (j' e y0)) =>
   iwpath_sup e (fun y0 : B' e => g y0))
  (x; (a, b))
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
      iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
     (x; (a, b)) y) =
y
      induction y as [a' b' IH] using IWPath_ind.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
a': A'
b': forall x0 : B' a', IWPath (j' a' x0)
IH: forall c : B' a',
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (j' a' c)
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c0 : B' e, IW I' A' B' i' j' (j' e c0)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (j' a' c) (b' c)) =
b' c
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (i' a')
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (i' a') (iwpath_sup a' b')) =
iwpath_sup a' b'
      rewrite IWPath_ind_beta_iwpath_sup.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
a': A'
b': forall x0 : B' a', IWPath (j' a' x0)
IH: forall c : B' a',
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (j' a' c)
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c0 : B' e, IW I' A' B' i' j' (j' e c0)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (j' a' c) (b' c)) =
b' c
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (i' a')
  (iw_sup I' A' B' i' j' a'
     (fun y : B' a' =>
      IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
        (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
           (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
         iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
        (j' a' y) (b' y))) =
iwpath_sup a' b'
      simpl; f_ap.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
a': A'
b': forall x0 : B' a', IWPath (j' a' x0)
IH: forall c : B' a',
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (j' a' c)
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c0 : B' e, IW I' A' B' i' j' (j' e c0)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (j' a' c) (b' c)) =
b' c
(fun y : B' a' =>
 IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
   (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
      (g : forall y0 : B' e, IWPath (j' e y0)) =>
    iwpath_sup e (fun y0 : B' e => g y0))
   (j' a' y)
   (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
      (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
         (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
       iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
      (j' a' y) (b' y))) =
b'
      funext c.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c0 : B e, IW I A B i j (j e c0)) *
(forall c0 : B e, IW I A B i j (j e c0))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c0 : B' k) => (j k.1 c0; (fst k.2 c0, snd k.2 c0)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
a': A'
b': forall x0 : B' a', IWPath (j' a' x0)
IH: forall c0 : B' a',
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (j' a' c0)
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c1 : B' e, IW I' A' B' i' j' (j' e c1)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (j' a' c0) (b' c0)) =
b' c0
c: B' a'
IW_rect I' A' B' i' j' (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
  (fun (e : A') (_ : forall y : B' e, IW I' A' B' i' j' (j' e y))
     (g : forall y : B' e, IWPath (j' e y)) =>
   iwpath_sup e (fun y : B' e => g y))
  (j' a' c)
  (IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
        (g : forall c0 : B' e, IW I' A' B' i' j' (j' e c0)) =>
      iw_sup I' A' B' i' j' e (fun y : B' e => g y))
     (j' a' c) (b' c)) =
b' c
      apply IH. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
(fun y : IWPath (x; (a, b)) =>
 let s := (x; (a, b)) in
 IWPath_ind (fun (s0 : I') (_ : IWPath s0) => IW I' A' B' i' j' s0)
   (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
      (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
    iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
   s y)
o (fun y : IW I' A' B' i' j' (x; (a, b)) =>
   let s := (x; (a, b)) in
   IW_rect I' A' B' i' j'
     (fun (s0 : I') (_ : IW I' A' B' i' j' s0) => IWPath s0)
     (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
        (g : forall y0 : B' e, IWPath (j' e y0)) =>
      iwpath_sup e (fun y0 : B' e => g y0))
     s y) ==
idmap
    intros y; cbn.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
y: IW I' A' B' i' j' (x; (a, b))
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e : A') (_ : forall x0 : B' e, IWPath (j' e x0))
     (g : forall c : B' e, IW I' A' B' i' j' (j' e c)) =>
   iw_sup I' A' B' i' j' e (fun y0 : B' e => g y0))
  (x; (a, b))
  (IW_rect I' A' B' i' j'
     (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
     (fun (e : A') (_ : forall y0 : B' e, IW I' A' B' i' j' (j' e y0))
        (g : forall y0 : B' e, IWPath (j' e y0)) =>
      iwpath_sup e (fun y0 : B' e => g y0))
     (x; (a, b)) y) =
y
    induction y as [e f IH].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y : B' e, IW I' A' B' i' j' (j' e y)
IH: forall y : B' e,
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
     (g : forall c : B' e0, IW I' A' B' i' j' (j' e0 c)) =>
   iw_sup I' A' B' i' j' e0 (fun y0 : B' e0 => g y0))
  (j' e y)
  (IW_rect I' A' B' i' j'
     (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
     (fun (e0 : A') (_ : forall y0 : B' e0, IW I' A' B' i' j' (j' e0 y0))
        (g : forall y0 : B' e0, IWPath (j' e0 y0)) =>
      iwpath_sup e0 (fun y0 : B' e0 => g y0))
     (j' e y) (f y)) =
f y
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
     (g : forall c : B' e0, IW I' A' B' i' j' (j' e0 c)) =>
   iw_sup I' A' B' i' j' e0 (fun y : B' e0 => g y))
  (i' e)
  (IW_rect I' A' B' i' j'
     (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
     (fun (e0 : A') (_ : forall y : B' e0, IW I' A' B' i' j' (j' e0 y))
        (g : forall y : B' e0, IWPath (j' e0 y)) =>
      iwpath_sup e0 (fun y : B' e0 => g y))
     (i' e) (iw_sup I' A' B' i' j' e f)) =
iw_sup I' A' B' i' j' e f
    rewrite IWPath_ind_beta_iwpath_sup.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c : B e0, IW I A B i j (j e0 c)) *
(forall c : B e0, IW I A B i j (j e0 c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y : B' e, IW I' A' B' i' j' (j' e y)
IH: forall y : B' e,
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
     (g : forall c : B' e0, IW I' A' B' i' j' (j' e0 c)) =>
   iw_sup I' A' B' i' j' e0 (fun y0 : B' e0 => g y0))
  (j' e y)
  (IW_rect I' A' B' i' j'
     (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
     (fun (e0 : A') (_ : forall y0 : B' e0, IW I' A' B' i' j' (j' e0 y0))
        (g : forall y0 : B' e0, IWPath (j' e0 y0)) =>
      iwpath_sup e0 (fun y0 : B' e0 => g y0))
     (j' e y) (f y)) =
f y
iw_sup I' A' B' i' j' e
  (fun y : B' e =>
   IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
     (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
        (g : forall c : B' e0, IW I' A' B' i' j' (j' e0 c)) =>
      iw_sup I' A' B' i' j' e0 (fun y0 : B' e0 => g y0))
     (j' e y)
     ((fix F (y0 : I') (i0 : IW I' A' B' i' j' y0) {struct i0} : IWPath y0 :=
         match i0 in (IW _ _ _ _ _ y1) return (IWPath y1) with
         | @iw_sup _ _ _ _ _ x0 i1 =>
             iwpath_sup x0 (fun y1 : B' x0 => F (j' x0 y1) (i1 y1))
         end)
        (j' e y) (f y))) =
iw_sup I' A' B' i' j' e f
    f_ap; funext c.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e0 : A &
(forall c0 : B e0, IW I A B i j (j e0 c0)) *
(forall c0 : B e0, IW I A B i j (j e0 c0))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c0 : B' k) => (j k.1 c0; (fst k.2 c0, snd k.2 c0)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: I
a, b: IW I A B i j x
e: A'
f: forall y : B' e, IW I' A' B' i' j' (j' e y)
IH: forall y : B' e,
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
     (g : forall c0 : B' e0, IW I' A' B' i' j' (j' e0 c0)) =>
   iw_sup I' A' B' i' j' e0 (fun y0 : B' e0 => g y0))
  (j' e y)
  (IW_rect I' A' B' i' j'
     (fun (s : I') (_ : IW I' A' B' i' j' s) => IWPath s)
     (fun (e0 : A') (_ : forall y0 : B' e0, IW I' A' B' i' j' (j' e0 y0))
        (g : forall y0 : B' e0, IWPath (j' e0 y0)) =>
      iwpath_sup e0 (fun y0 : B' e0 => g y0))
     (j' e y) (f y)) =
f y
c: B' e
IWPath_ind (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e0 : A') (_ : forall x0 : B' e0, IWPath (j' e0 x0))
     (g : forall c0 : B' e0, IW I' A' B' i' j' (j' e0 c0)) =>
   iw_sup I' A' B' i' j' e0 (fun y : B' e0 => g y))
  (j' e c)
  ((fix F (y : I') (i0 : IW I' A' B' i' j' y) {struct i0} : IWPath y :=
      match i0 in (IW _ _ _ _ _ y0) return (IWPath y0) with
      | @iw_sup _ _ _ _ _ x0 i1 =>
          iwpath_sup x0 (fun y0 : B' x0 => F (j' x0 y0) (i1 y0))
      end)
     (j' e c) (f c)) =
f c
    apply IH.
  Defined.

  (** ** Characterization of fiber *)

  (** We begin with two auxiliary lemmas that will be explained shortly. *)
  Local Definition adjust_hfiber {X Y} {f : X -> Y} {y z}
    : hfiber f y -> y = z -> hfiber f z
    := fun '(x ; p) => match p with idpath => fun q => (x ; q) end.

  Local Definition adjust_hfiber_idpath {X Y} {f : X -> Y} {y xp}
    : adjust_hfiber (f:=f) xp (idpath : y = y) = xp.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X0 : A' => B X0.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
X, Y: Type
f: X -> Y
y: Y
xp: hfiber f y
adjust_hfiber xp (1 : y = y) = xp
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X0 : A' => B X0.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
X, Y: Type
f: X -> Y
y: Y
xp: hfiber f y
adjust_hfiber xp (1 : y = y) = xp
    by destruct xp as [x []].
  Defined.

  (** We wish to show an induction principle coming from the path type of the fiber. However to do this we need to be a bit more general by allowing the elements of the IW-type to differ in label up to equality. This allows us to do prove this induction principle easily, and later we will derive the induction principle where the labels are the same. *)
  Local Definition path_iw_to_hfiber_ind'
    (P : forall (la lb : I) (le : lb = la) (a : IW I A B i j la) (b : IW I A B i j lb),
      iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le -> Type)
    (h : forall x a b,
      P (i x) (i x) idpath (iw_sup I A B i j x a) (iw_sup I A B i j x b) idpath)
    : forall la lb le a b p, P la lb le a b p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la lb : I) (le : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
forall (la lb : I) (le : lb = la) (a : IW I A B i j la) 
(b : IW I A B i j lb)
(p : iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le),
P la lb le a b p
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la lb : I) (le : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
forall (la lb : I) (le : lb = la) (a : IW I A B i j la) 
(b : IW I A B i j lb)
(p : iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le),
P la lb le a b p
    intros la lb le a b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la0 lb0 : I) (le0 : lb0 = la0) (a0 : IW I A B i j la0)
(b0 : IW I A B i j lb0),
iw_to_hfiber_index la0 a0 = adjust_hfiber (iw_to_hfiber_index lb0 b0) le0 ->
Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
la, lb: I
le: lb = la
a: IW I A B i j la
b: IW I A B i j lb
forall
p : iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le,
P la lb le a b p
    destruct a as [xa cha], b as [xb chb].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la lb : I) (le0 : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le0 -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
xa, xb: A
le: i xb = i xa
cha: forall y : B xa, IW I A B i j (j xa y)
chb: forall y : B xb, IW I A B i j (j xb y)
forall
p : iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha) =
    adjust_hfiber (iw_to_hfiber_index (i xb) (iw_sup I A B i j xb chb)) le,
P (i xa) (i xb) le (iw_sup I A B i j xa cha) (iw_sup I A B i j xb chb) p
    intros p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la lb : I) (le0 : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le0 -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
xa, xb: A
le: i xb = i xa
cha: forall y : B xa, IW I A B i j (j xa y)
chb: forall y : B xb, IW I A B i j (j xb y)
p: iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha) =
adjust_hfiber (iw_to_hfiber_index (i xb) (iw_sup I A B i j xb chb)) le
P (i xa) (i xb) le (iw_sup I A B i j xa cha) (iw_sup I A B i j xb chb) p
    refine (paths_ind _
      (fun _ q => forall chb, P _ _ _ _ (iw_sup _ _ _ _ _ _ chb) q) _ _ p chb).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (la lb : I) (le0 : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le0 -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (i x) 1 (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
xa, xb: A
le: i xb = i xa
cha: forall y : B xa, IW I A B i j (j xa y)
chb: forall y : B xb, IW I A B i j (j xb y)
p: iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha) =
adjust_hfiber (iw_to_hfiber_index (i xb) (iw_sup I A B i j xb chb)) le
forall
chb0 : forall y : B (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1,
       IW I A B i j
         (j (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1 y),
P (i xa) (i (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1)
  (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).2
  (iw_sup I A B i j xa cha)
  (iw_sup I A B i j (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1
     chb0)
  1
    intros x.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (la lb : I) (le0 : lb = la) (a : IW I A B i j la)
(b : IW I A B i j lb),
iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le0 -> Type
h: forall (x0 : A) (a b : forall y : B x0, IW I A B i j (j x0 y)),
P (i x0) (i x0) 1 (iw_sup I A B i j x0 a) (iw_sup I A B i j x0 b) 1
xa, xb: A
le: i xb = i xa
cha: forall y : B xa, IW I A B i j (j xa y)
chb: forall y : B xb, IW I A B i j (j xb y)
p: iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha) =
adjust_hfiber (iw_to_hfiber_index (i xb) (iw_sup I A B i j xb chb)) le
x: forall y : B (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1,
IW I A B i j (j (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1 y)
P (i xa) (i (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1)
  (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).2
  (iw_sup I A B i j xa cha)
  (iw_sup I A B i j (iw_to_hfiber_index (i xa) (iw_sup I A B i j xa cha)).1 x)
  1
    apply h.
  Defined.

  (** Induction principle for paths in the fiber. *)
  Local Definition path_iw_to_hfiber_ind
    (P : forall (l : I) (a b : IW I A B i j l),
      iw_to_hfiber_index l a = iw_to_hfiber_index l b -> Type)
    (h : forall x a b,
      P (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) idpath)
    : forall l a b p, P l a b p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l : I) (a b : IW I A B i j l),
iw_to_hfiber_index l a = iw_to_hfiber_index l b -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
forall (l : I) (a b : IW I A B i j l)
(p : iw_to_hfiber_index l a = iw_to_hfiber_index l b), 
P l a b p
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l : I) (a b : IW I A B i j l),
iw_to_hfiber_index l a = iw_to_hfiber_index l b -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1
forall (l : I) (a b : IW I A B i j l)
(p : iw_to_hfiber_index l a = iw_to_hfiber_index l b), 
P l a b p
    intros l a b p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
P l a b p 
    transparent assert (Q : (forall (la lb : I) (le : lb = la)
      (a : IW I A B i j la) (b : IW I A B i j lb),
      iw_to_hfiber_index la a = adjust_hfiber (iw_to_hfiber_index lb b) le -> Type)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= ?Goal: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
P l a b p
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type intros la lb le.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
la, lb: I
le: lb = la
forall (a0 : IW I A B i j la) (b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
      destruct le.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
lb: I
forall a0 b0 : IW I A B i j lb,
iw_to_hfiber_index lb a0 = adjust_hfiber (iw_to_hfiber_index lb b0) 1 -> Type
      intros a' b' p'.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
lb: I
a', b': IW I A B i j lb
p': iw_to_hfiber_index lb a' = adjust_hfiber (iw_to_hfiber_index lb b') 1
Type
      refine (P lb _ _ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
lb: I
a', b': IW I A B i j lb
p': iw_to_hfiber_index lb a' = adjust_hfiber (iw_to_hfiber_index lb b') 1
iw_to_hfiber_index lb ?Goal0 = iw_to_hfiber_index lb ?Goal1
      exact (p' @ adjust_hfiber_idpath). }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
P l a b p
    transparent assert (h' : ((forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
        Q (i x) (i x) idpath (iw_sup I A B i j x a) (iw_sup I A B i j x b) idpath))).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
h':= ?Goal: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
P l a b p
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1 intros x a' b'.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x0 : A) (a0 b0 : forall y : B x0, IW I A B i j (j x0 y)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a'0 b'0 : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a'0 =
            adjust_hfiber (iw_to_hfiber_index lb b'0) 1) =>
    P lb a'0 b'0 (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
x: A
a', b': forall y : B x, IW I A B i j (j x y)
Q (i x) (i x) 1 (iw_sup I A B i j x a') (iw_sup I A B i j x b') 1
      apply h. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
h':= fun (x : A) (a' b' : forall y : B x, IW I A B i j (j x y)) => h x a' b': forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
P l a b p
    pose (path_iw_to_hfiber_ind' Q h' l l idpath a b (p @ adjust_hfiber_idpath^)) as q.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
h':= fun (x : A) (a' b' : forall y : B x, IW I A B i j (j x y)) => h x a' b': forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
q:= path_iw_to_hfiber_ind' Q h' l l 1 a b (p @ adjust_hfiber_idpath^): Q l l 1 a b (p @ adjust_hfiber_idpath^)
P l a b p
    refine (transport (P l a b) _ q).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0),
iw_to_hfiber_index l0 a0 = iw_to_hfiber_index l0 b0 -> Type
h: forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
l: I
a, b: IW I A B i j l
p: iw_to_hfiber_index l a = iw_to_hfiber_index l b
Q:= fun (la lb : I) (le : lb = la) =>
match
  le as p0 in (_ = i0)
  return
    (forall (a0 : IW I A B i j i0) (b0 : IW I A B i j lb),
     iw_to_hfiber_index i0 a0 = adjust_hfiber (iw_to_hfiber_index lb b0) p0 ->
     Type)
with
| 1 =>
    fun (a' b' : IW I A B i j lb)
      (p' : iw_to_hfiber_index lb a' =
            adjust_hfiber (iw_to_hfiber_index lb b') 1) =>
    P lb a' b' (p' @ adjust_hfiber_idpath)
end: forall (la lb : I) (le : lb = la) (a0 : IW I A B i j la)
(b0 : IW I A B i j lb),
iw_to_hfiber_index la a0 = adjust_hfiber (iw_to_hfiber_index lb b0) le ->
Type
h':= fun (x : A) (a' b' : forall y : B x, IW I A B i j (j x y)) => h x a' b': forall (x : A) (a0 b0 : forall y : B x, IW I A B i j (j x y)),
Q (i x) (i x) 1 (iw_sup I A B i j x a0) (iw_sup I A B i j x b0) 1
q:= path_iw_to_hfiber_ind' Q h' l l 1 a b (p @ adjust_hfiber_idpath^): Q l l 1 a b (p @ adjust_hfiber_idpath^)
(p @ adjust_hfiber_idpath^) @ adjust_hfiber_idpath = p
    apply concat_pV_p.
  Defined.

  (** Induction principle for families over hfiber of i' *)
  Local Definition hfiber_ind
    (P : forall l a b, hfiber i' (l; (a, b)) -> Type)
    (h : forall x a b, P (i x) (iw_sup I A B i j x a)
      (iw_sup I A B i j x b) ((x; (a, b)); idpath))
    : forall l a b p, P l a b p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l : I) (a b : IW I A B i j l), hfiber i' (l; (a, b)) -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) ((x; (a, b)); 1)
forall (l : I) (a b : IW I A B i j l) (p : hfiber i' (l; (a, b))), P l a b p
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
P: forall (l : I) (a b : IW I A B i j l), hfiber i' (l; (a, b)) -> Type
h: forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
P (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) ((x; (a, b)); 1)
forall (l : I) (a b : IW I A B i j l) (p : hfiber i' (l; (a, b))), P l a b p
    intros l a b [[x [y z]] p].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0), hfiber i' (l0; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
l: I
a, b: IW I A B i j l
x: A
y, z: forall c : B x, IW I A B i j (j x c)
p: i' (x; (y, z)) = (l; (a, b))
P l a b ((x; (y, z)); p)
    unfold i', functor_sigma, functor_prod in p; simpl in p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0), hfiber i' (l0; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
l: I
a, b: IW I A B i j l
x: A
y, z: forall c : B x, IW I A B i j (j x c)
p: (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) = (l; (a, b))
P l a b ((x; (y, z)); p)
    revert p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0), hfiber i' (l0; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
l: I
a, b: IW I A B i j l
x: A
y, z: forall c : B x, IW I A B i j (j x c)
forall p : (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) = (l; (a, b)),
P l a b ((x; (y, z)); p)
    refine (equiv_ind (equiv_path_sigma _ _ _) _ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0), hfiber i' (l0; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
l: I
a, b: IW I A B i j l
x: A
y, z: forall c : B x, IW I A B i j (j x c)
forall
x0 : {p
     : (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)).1 = (l; (a, b)).1
     &
     transport (fun k : I => IW I A B i j k * IW I A B i j k) p
       (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)).2 =
     (l; (a, b)).2},
P l a b
  ((x; (y, z));
  equiv_path_sigma (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (l; (a, b)) x0)
    intros [p q]; simpl in p, q.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l0 : I) (a0 b0 : IW I A B i j l0), hfiber i' (l0; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
l: I
a, b: IW I A B i j l
x: A
y, z: forall c : B x, IW I A B i j (j x c)
p: i x = l
q: transport (fun k : I => IW I A B i j k * IW I A B i j k) p
  (iw_sup I A B i j x y, iw_sup I A B i j x z) =
(a, b)
P l a b
  ((x; (y, z));
  equiv_path_sigma (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (l; (a, b)) (p; q))
    destruct p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l : I) (a0 b0 : IW I A B i j l), hfiber i' (l; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
x: A
a, b: IW I A B i j (i x)
y, z: forall c : B x, IW I A B i j (j x c)
q: transport (fun k : I => IW I A B i j k * IW I A B i j k) 1
  (iw_sup I A B i j x y, iw_sup I A B i j x z) =
(a, b)
P (i x) a b
  ((x; (y, z));
  equiv_path_sigma (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (i x; (a, b)) (1; q))
    revert q; cbn.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l : I) (a0 b0 : IW I A B i j l), hfiber i' (l; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
x: A
a, b: IW I A B i j (i x)
y, z: forall c : B x, IW I A B i j (j x c)
forall q : (iw_sup I A B i j x y, iw_sup I A B i j x z) = (a, b),
P (i x) a b
  ((x; (y, z));
  path_sigma_uncurried (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (i x; (a, b)) (1; q))
    refine (equiv_ind (equiv_path_prod _ _) _ _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l : I) (a0 b0 : IW I A B i j l), hfiber i' (l; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
x: A
a, b: IW I A B i j (i x)
y, z: forall c : B x, IW I A B i j (j x c)
forall
x0 : (fst (iw_sup I A B i j x y, iw_sup I A B i j x z) = fst (a, b)) *
     (snd (iw_sup I A B i j x y, iw_sup I A B i j x z) = snd (a, b)),
P (i x) a b
  ((x; (y, z));
  path_sigma_uncurried (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (i x; (a, b))
    (1;
    equiv_path_prod (iw_sup I A B i j x y, iw_sup I A B i j x z) (a, b) x0))
    cbn; intros [p q].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l : I) (a0 b0 : IW I A B i j l), hfiber i' (l; (a0, b0)) -> Type
h: forall (x0 : A) (a0 b0 : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a0) (iw_sup I A B i j x0 b0)
  ((x0; (a0, b0)); 1)
x: A
a, b: IW I A B i j (i x)
y, z: forall c : B x, IW I A B i j (j x c)
p: iw_sup I A B i j x y = a
q: iw_sup I A B i j x z = b
P (i x) a b
  ((x; (y, z));
  path_sigma_uncurried (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z)) 
    (i x; (a, b))
    (1;
    path_prod_uncurried (iw_sup I A B i j x y, iw_sup I A B i j x z) 
      (a, b) (p, q)))
    destruct p, q.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
P: forall (l : I) (a b : IW I A B i j l), hfiber i' (l; (a, b)) -> Type
h: forall (x0 : A) (a b : forall y0 : B x0, IW I A B i j (j x0 y0)),
P (i x0) (iw_sup I A B i j x0 a) (iw_sup I A B i j x0 b) ((x0; (a, b)); 1)
x: A
y, z: forall c : B x, IW I A B i j (j x c)
P (i x) (iw_sup I A B i j x y) (iw_sup I A B i j x z)
  ((x; (y, z));
  path_sigma_uncurried (fun k : I => IW I A B i j k * IW I A B i j k)
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z))
    (i x; (iw_sup I A B i j x y, iw_sup I A B i j x z))
    (1;
    path_prod_uncurried (iw_sup I A B i j x y, iw_sup I A B i j x z)
      (iw_sup I A B i j x y, iw_sup I A B i j x z) 
      (1, 1)))
    apply h.
  Defined.

  Local Definition path_iw_to_hfiber l a b
    : iw_to_hfiber_index l a = iw_to_hfiber_index l b -> hfiber i' (l; (a, b))
    := path_iw_to_hfiber_ind (fun l a b _ => hfiber i' (l ; (a, b)))
        (fun x a b => ((x ; (a, b)); idpath)) l a b.

  Local Definition hfiber_to_path_iw l a b
    : hfiber i' (l; (a, b)) -> iw_to_hfiber_index l a = iw_to_hfiber_index l b
    := hfiber_ind
        (fun l a b _ => iw_to_hfiber_index l a = iw_to_hfiber_index l b)
        (fun x a b => idpath) l a b.

  Local Definition path_iw_to_hfiber_to_path_iw
    : forall l a b p, path_iw_to_hfiber l a b (hfiber_to_path_iw l a b p) = p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (l : I) (a b : IW I A B i j l) (p : hfiber i' (l; (a, b))),
path_iw_to_hfiber l a b (hfiber_to_path_iw l a b p) = p
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (l : I) (a b : IW I A B i j l) (p : hfiber i' (l; (a, b))),
path_iw_to_hfiber l a b (hfiber_to_path_iw l a b p) = p
    refine (hfiber_ind (fun l a b p
      => path_iw_to_hfiber l a b (hfiber_to_path_iw l a b p) = p) _).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
path_iw_to_hfiber (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b)
  (hfiber_to_path_iw (i x) (iw_sup I A B i j x a) 
     (iw_sup I A B i j x b) ((x; (a, b)); 1)) =
((x; (a, b)); 1)
    intros x a b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a, b: forall y : B x, IW I A B i j (j x y)
path_iw_to_hfiber (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b)
  (hfiber_to_path_iw (i x) (iw_sup I A B i j x a) 
     (iw_sup I A B i j x b) ((x; (a, b)); 1)) =
((x; (a, b)); 1)
    reflexivity.
  Defined.

  Local Definition hfiber_to_path_iw_to_hfiber
    : forall l a b p, hfiber_to_path_iw l a b (path_iw_to_hfiber l a b p) = p.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (l : I) (a b : IW I A B i j l)
(p : iw_to_hfiber_index l a = iw_to_hfiber_index l b),
hfiber_to_path_iw l a b (path_iw_to_hfiber l a b p) = p
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (l : I) (a b : IW I A B i j l)
(p : iw_to_hfiber_index l a = iw_to_hfiber_index l b),
hfiber_to_path_iw l a b (path_iw_to_hfiber l a b p) = p
    rapply path_iw_to_hfiber_ind.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
forall (x : A) (a b : forall y : B x, IW I A B i j (j x y)),
hfiber_to_path_iw (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b)
  (path_iw_to_hfiber (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1) =
1
    intros x a b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x0 : I' => fst x0.2 = snd x0.2: I' -> Type
x: A
a, b: forall y : B x, IW I A B i j (j x y)
hfiber_to_path_iw (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b)
  (path_iw_to_hfiber (i x) (iw_sup I A B i j x a) (iw_sup I A B i j x b) 1) =
1
    reflexivity.
  Defined.

  (** The path type of the fibers of [i] is equivalent to the fibers of [i']. *)
  Definition equiv_path_hfiber_index (l : I) (a b : IW I A B i j l)
    : iw_to_hfiber_index l a = iw_to_hfiber_index l b <~> hfiber i' (l; (a, b)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
iw_to_hfiber_index l a = iw_to_hfiber_index l b <~> hfiber i' (l; (a, b))
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
iw_to_hfiber_index l a = iw_to_hfiber_index l b <~> hfiber i' (l; (a, b))
    srapply equiv_adjointify.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
iw_to_hfiber_index l a = iw_to_hfiber_index l b -> hfiber i' (l; (a, b))
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
hfiber i' (l; (a, b)) -> iw_to_hfiber_index l a = iw_to_hfiber_index l b
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
?f o ?g == idmap
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
?g o ?f == idmap
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
iw_to_hfiber_index l a = iw_to_hfiber_index l b -> hfiber i' (l; (a, b)) apply path_iw_to_hfiber.
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
hfiber i' (l; (a, b)) -> iw_to_hfiber_index l a = iw_to_hfiber_index l b apply hfiber_to_path_iw.
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
path_iw_to_hfiber l a b o hfiber_to_path_iw l a b == idmap rapply path_iw_to_hfiber_to_path_iw.
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
I':= {k : I & IW I A B i j k * IW I A B i j k}: Type
A':= {e : A &
(forall c : B e, IW I A B i j (j e c)) *
(forall c : B e, IW I A B i j (j e c))}: Type
B':= fun X : A' => B X.1: A' -> Type
i':= functor_sigma i
  (fun a0 : A => functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)): A' -> I'
j':= fun (k : A') (c : B' k) => (j k.1 c; (fst k.2 c, snd k.2 c)): forall k : A', B' k -> I'
IWPath:= fun x : I' => fst x.2 = snd x.2: I' -> Type
l: I
a, b: IW I A B i j l
hfiber_to_path_iw l a b o path_iw_to_hfiber l a b == idmap rapply hfiber_to_path_iw_to_hfiber.
  Defined.

End Paths.

(** Some properties of the (fibers of the) index map [i] hold for the IW-type as well. For example, if [i] is an embedding then the corresponding IW-type is a hprop. *)

(** ** IW-types preserve truncation *)

(** We can show that if the index map is an embedding then the IW-type is a hprop. *)
Instance ishprop_iwtype `{Funext}
  (I : Type) (A : Type) (B : A -> Type)
  (i : A -> I) (j : forall x, B x -> I) {h : IsEmbedding i}
  : forall x, IsHProp (IW I A B i j x).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsEmbedding i
forall x : I, IsHProp (IW I A B i j x)
Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsEmbedding i
forall x : I, IsHProp (IW I A B i j x)
  intros l.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsEmbedding i
l: I
IsHProp (IW I A B i j l)
  apply hprop_allpath.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsEmbedding i
l: I
forall x y : IW I A B i j l, x = y
  intros x.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
l: I
x: IW I A B i j l
forall y : IW I A B i j l, x = y
  induction x as [x x' IHx].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y0 : IW I A B i j (j x y)), x' y = y0
forall y : IW I A B i j (i x), iw_sup I A B i j x x' = y
  intros y.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y0 : B x, IW I A B i j (j x y0)
IHx: forall (y0 : B x) (y1 : IW I A B i j (j x y0)), x' y0 = y1
y: IW I A B i j (i x)
iw_sup I A B i j x x' = y 
  (** We need to induct on y and at the same time generalize the goal to become a dependent equality. This can be difficult to do with tactics so we just refine the corresponding match statement. All we have done is turn the RHS into a transport over an equality allowing the induction on y to go through. *)
  refine (
    match y in (IW _ _ _ _ _ l)
      return (forall q : l = i x,
        iw_sup I A B i j x x' = q # y)
    with iw_sup y y' => _ end idpath).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
forall q : i y = i x,
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  intros q.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
q: i y = i x
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  pose (r := @path_ishprop _ (h (i x)) (x; idpath) (y; q)).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
q: i y = i x
r:= path_ishprop (x; 1) (y; q): (x; 1) = (y; q)
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  set (r2 := r..2); cbn in r2.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
q: i y = i x
r:= path_ishprop (x; 1) (y; q): (x; 1) = (y; q)
r2:= r ..2: transport (fun x0 : A => i x0 = i x) r ..1 1 = q
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  set (r1 := r..1) in r2; cbn in r1.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
q: i y = i x
r:= path_ishprop (x; 1) (y; q): (x; 1) = (y; q)
r1:= r ..1: x = y
r2:= r ..2: transport (fun x0 : A => i x0 = i x) r1 1 = q
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  clearbody r1 r2.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y1 : B x, IW I A B i j (j x y1)
IHx: forall (y1 : B x) (y2 : IW I A B i j (j x y1)), x' y1 = y2
y0: IW I A B i j (i x)
y: A
y': forall y1 : B y, IW I A B i j (j y y1)
q: i y = i x
r:= path_ishprop (x; 1) (y; q): (x; 1) = (y; q)
r1: x = y
r2: transport (fun x0 : A => i x0 = i x) r1 1 = q
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j y y')
  destruct r1.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y1 : IW I A B i j (j x y)), x' y = y1
y0: IW I A B i j (i x)
y': forall y : B x, IW I A B i j (j x y)
q: i x = i x
r:= path_ishprop (x; 1) (x; q): (x; 1) = (x; q)
r2: transport (fun x0 : A => i x0 = i x) 1 1 = q
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j x y')
  simpl in r2.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y1 : IW I A B i j (j x y)), x' y = y1
y0: IW I A B i j (i x)
y': forall y : B x, IW I A B i j (j x y)
q: i x = i x
r:= path_ishprop (x; 1) (x; q): (x; 1) = (x; q)
r2: 1 = q
iw_sup I A B i j x x' = transport (IW I A B i j) q (iw_sup I A B i j x y')
  destruct r2.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y1 : IW I A B i j (j x y)), x' y = y1
y0: IW I A B i j (i x)
y': forall y : B x, IW I A B i j (j x y)
r:= path_ishprop (x; 1) (x; 1): (x; 1) = (x; 1)
iw_sup I A B i j x x' = transport (IW I A B i j) 1 (iw_sup I A B i j x y')
  cbn; f_ap.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y1 : IW I A B i j (j x y)), x' y = y1
y0: IW I A B i j (i x)
y': forall y : B x, IW I A B i j (j x y)
r:= path_ishprop (x; 1) (x; 1): (x; 1) = (x; 1)
x' = y'
  funext a.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsEmbedding i
x: A
x': forall y : B x, IW I A B i j (j x y)
IHx: forall (y : B x) (y1 : IW I A B i j (j x y)), x' y = y1
y0: IW I A B i j (i x)
y': forall y : B x, IW I A B i j (j x y)
r:= path_ishprop (x; 1) (x; 1): (x; 1) = (x; 1)
a: B x
x' a = y' a
  apply IHx.
Defined.

(** Now by induction on truncation indices we show that IW-types are n.+1 truncated if the index maps are also n.+1 truncated. *)
Instance istrunc_iwtype `{Funext}
  (I : Type) (A : Type) (B : A -> Type) (i : A -> I)
  (j : forall x, B x -> I) (n : trunc_index) {h : IsTruncMap n.+1 i} (l : I)
  : IsTrunc n.+1 (IW I A B i j l).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
n: trunc_index
h: IsTruncMap n.+1 i
l: I
IsTrunc n.+1 (IW I A B i j l)
Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
n: trunc_index
h: IsTruncMap n.+1 i
l: I
IsTrunc n.+1 (IW I A B i j l)
  (** We need a general induction hypothesis *)
  revert n I A B i j h l.
H: Funext
forall (n : trunc_index) (I A : Type) (B : A -> Type) 
(i : A -> I) (j : forall x : A, B x -> I),
IsTruncMap n.+1 i -> forall l : I, IsTrunc n.+1 (IW I A B i j l)
  induction n as [|n IHn].
H: Funext
forall (I A : Type) (B : A -> Type) (i : A -> I)
(j : forall x : A, B x -> I),
IsEmbedding i -> forall l : I, IsHProp (IW I A B i j l)
H: Funext
n: trunc_index
IHn: forall (I A : Type) (B : A -> Type) (i : A -> I)
(j : forall x : A, B x -> I),
IsTruncMap n.+1 i -> forall l : I, IsTrunc n.+1 (IW I A B i j l)
forall (I A : Type) (B : A -> Type) (i : A -> I)
(j : forall x : A, B x -> I),
IsTruncMap n.+2 i -> forall l : I, IsTrunc n.+2 (IW I A B i j l)
  1: exact ishprop_iwtype.
H: Funext
n: trunc_index
IHn: forall (I A : Type) (B : A -> Type) (i : A -> I)
(j : forall x : A, B x -> I),
IsTruncMap n.+1 i -> forall l : I, IsTrunc n.+1 (IW I A B i j l)
forall (I A : Type) (B : A -> Type) (i : A -> I)
(j : forall x : A, B x -> I),
IsTruncMap n.+2 i -> forall l : I, IsTrunc n.+2 (IW I A B i j l)
  intros I A B i j h l.
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x : A0, B0 x -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsTruncMap n.+2 i
l: I
IsTrunc n.+2 (IW I A B i j l)
  apply istrunc_S.
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x : A0, B0 x -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
h: IsTruncMap n.+2 i
l: I
forall x y : IW I A B i j l, IsTrunc n.+1 (x = y)
  intros x y.
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x0 : A0, B0 x0 -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsTruncMap n.+2 i
l: I
x, y: IW I A B i j l
IsTrunc n.+1 (x = y)
  refine (istrunc_equiv_istrunc _
    (equiv_path_iwtype I A B i j l x y) (n := n.+1)).
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x0 : A0, B0 x0 -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsTruncMap n.+2 i
l: I
x, y: IW I A B i j l
IsTrunc n.+1
  (IW {k : I & IW I A B i j k * IW I A B i j k}
     {e : A &
     (forall c : B e, IW I A B i j (j e c)) *
     (forall c : B e, IW I A B i j (j e c))}
     (fun
        X : {e : A &
            (forall c : B e, IW I A B i j (j e c)) *
            (forall c : B e, IW I A B i j (j e c))} =>
      B X.1)
     (functor_sigma i
        (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)))
     (fun
        (k : {e : A &
             (forall c : B e, IW I A B i j (j e c)) *
             (forall c : B e, IW I A B i j (j e c))})
        (c : B k.1) =>
      (j k.1 c; (fst k.2 c, snd k.2 c)))
     (l; (x, y)))
  apply IHn.
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x0 : A0, B0 x0 -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsTruncMap n.+2 i
l: I
x, y: IW I A B i j l
IsTruncMap n.+1
  (functor_sigma i
     (fun a : A => functor_prod (iw_sup I A B i j a) (iw_sup I A B i j a)))
  intros [k [a b]].
H: Funext
n: trunc_index
IHn: forall (I0 A0 : Type) (B0 : A0 -> Type) (i0 : A0 -> I0)
(j0 : forall x0 : A0, B0 x0 -> I0),
IsTruncMap n.+1 i0 -> forall l0 : I0, IsTrunc n.+1 (IW I0 A0 B0 i0 j0 l0)
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
h: IsTruncMap n.+2 i
l: I
x, y: IW I A B i j l
k: I
a, b: IW I A B i j k
IsTrunc n.+1
  (hfiber
     (functor_sigma i
        (fun a0 : A =>
         functor_prod (iw_sup I A B i j a0) (iw_sup I A B i j a0)))
     (k; (a, b)))
  (** The crucial step is to characterize the fiber of [i'] which was done previously. *)
  exact (istrunc_equiv_istrunc _
    (equiv_path_hfiber_index I A B i j k a b)).
Defined.

(** ** Decidable equality for IW-types *)

(** If A has decidable paths then it is a hset and therefore equality of sigma types over it are determined by the second component. *)
Local Definition inj_right_pair_on
  {A : Type} {A_dec : DecidablePaths A}
  (P : A -> Type) (x : A) (y y' : P x)
    (H : (x; y) = (x; y')) : y = y'.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
H: (x; y) = (x; y')
y = y'
Proof.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
H: (x; y) = (x; y')
y = y'
  apply (equiv_path_sigma _ _ _)^-1%equiv in H.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
H: {p : (x; y).1 = (x; y').1 & transport P p (x; y).2 = (x; y').2}
y = y'
  destruct H as [p q]; cbn in p, q.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
p: x = x
q: transport P p y = y'
y = y'
  assert (r : idpath = p) by apply path_ishprop.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
p: x = x
q: transport P p y = y'
r: 1 = p
y = y'
  destruct r.
A: Type
A_dec: DecidablePaths A
P: A -> Type
x: A
y, y': P x
q: transport P 1 y = y'
y = y'
  exact q.
Defined.

(** IW-types have decidable equality if [liftP] holds and the fibers of the indexing map have decidable paths. Notably, if B x is finitely enumerable, then [liftP] holds. *)
Section DecidablePaths.

  Context `{Funext}
    (I : Type) (A : Type) (B : A -> Type) (i : A -> I) (j : forall x, B x -> I)
    (liftP : forall (x : A) (P : B x -> Type),
     (forall c, Decidable (P c)) -> Decidable (forall c, P c))
    (fibers_dec : forall x, DecidablePaths (hfiber i x)).

  Let children_for (x : A) : Type := forall c, IW I A B i j (j x c).
  Let getfib {x} (a : IW I A B i j x) : hfiber i x
    := match a with iw_sup x _ => (x ; idpath) end.
  Let getfib_computes x y children p
    : getfib (paths_rec (i y) _ (iw_sup _ _ _ _ _ y children) (i x) p) = exist _ y p
    := match p
         return getfib (paths_rec _ _ (iw_sup _ _ _ _ _ y children) _ p) = exist _ y p
       with idpath => idpath end.
  Let getfib_plus {x} (a : IW I A B i j x)
    : {f : hfiber i x & children_for (pr1 f)}
    := match a with iw_sup x c => ((x; idpath); c) end.
  Let children_eq (x : A) (c1 c2 : forall c, IW I A B i j (j x c))
    : iw_sup I A B i j x c1 = iw_sup I A B i j x c2 -> c1 = c2
    := fun r => inj_right_pair_on (fun f => children_for (pr1 f))
         (x; idpath) _ _ (ap getfib_plus r).

  Fixpoint decide_eq l (a : IW I A B i j l) : forall b, Decidable (a = b).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
liftP: forall (x : A) (P : B x -> Type),
(forall c : B x, Decidable (P c)) -> Decidable (forall c : B x, P c)
fibers_dec: forall x : I, DecidablePaths (hfiber i x)
children_for:= fun x : A => forall c : B x, IW I A B i j (j x c): A -> Type
getfib:= fun (x : I) (a0 : IW I A B i j x) =>
match a0 in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x0 _ => (x0; 1)
end: forall x : I, IW I A B i j x -> hfiber i x
getfib_computes:= fun (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x),
getfib (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x) p) =
(y; p)
getfib_plus:= fun (x : I) (a0 : IW I A B i j x) =>
match
  a0 in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1}
with
| @iw_sup _ _ _ _ _ x0 c => ((x0; 1); c)
end: forall x : I, IW I A B i j x -> {f : hfiber i x & children_for f.1}
children_eq:= fun (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c))
  (r : iw_sup I A B i j x c1 = iw_sup I A B i j x c2) =>
inj_right_pair_on (fun f : {x0 : A & i x0 = i x} => children_for f.1) 
  (x; 1) c1 c2 (ap getfib_plus r): forall (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c)),
iw_sup I A B i j x c1 = iw_sup I A B i j x c2 -> c1 = c2
decide_eq: forall (l0 : I) (a0 b : IW I A B i j l0), Decidable (a0 = b)
l: I
a: IW I A B i j l
forall b : IW I A B i j l, Decidable (a = b)
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
liftP: forall (x : A) (P : B x -> Type),
(forall c : B x, Decidable (P c)) -> Decidable (forall c : B x, P c)
fibers_dec: forall x : I, DecidablePaths (hfiber i x)
children_for:= fun x : A => forall c : B x, IW I A B i j (j x c): A -> Type
getfib:= fun (x : I) (a0 : IW I A B i j x) =>
match a0 in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x0 _ => (x0; 1)
end: forall x : I, IW I A B i j x -> hfiber i x
getfib_computes:= fun (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x),
getfib (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x) p) =
(y; p)
getfib_plus:= fun (x : I) (a0 : IW I A B i j x) =>
match
  a0 in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1}
with
| @iw_sup _ _ _ _ _ x0 c => ((x0; 1); c)
end: forall x : I, IW I A B i j x -> {f : hfiber i x & children_for f.1}
children_eq:= fun (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c))
  (r : iw_sup I A B i j x c1 = iw_sup I A B i j x c2) =>
inj_right_pair_on (fun f : {x0 : A & i x0 = i x} => children_for f.1) 
  (x; 1) c1 c2 (ap getfib_plus r): forall (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c)),
iw_sup I A B i j x c1 = iw_sup I A B i j x c2 -> c1 = c2
decide_eq: forall (l0 : I) (a0 b : IW I A B i j l0), Decidable (a0 = b)
l: I
a: IW I A B i j l
forall b : IW I A B i j l, Decidable (a = b)
    destruct a as [x c1].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b : IW I A B i j l), Decidable (a = b)
x: A
c1: forall y : B x, IW I A B i j (j x y)
forall b : IW I A B i j (i x), Decidable (iw_sup I A B i j x c1 = b)
    intro b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
Decidable (iw_sup I A B i j x c1 = b)
    transparent assert (decide_children : (forall c2, Decidable (c1 = c2))).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
forall c2 : forall y : B x, IW I A B i j (j x y), Decidable (c1 = c2)
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
decide_children:= ?Goal: forall c2 : forall y : B x, IW I A B i j (j x y), Decidable (c1 = c2)
Decidable (iw_sup I A B i j x c1 = b)
    {
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
forall c2 : forall y : B x, IW I A B i j (j x y), Decidable (c1 = c2) intros c2.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
c2: forall y : B x, IW I A B i j (j x y)
Decidable (c1 = c2)
      destruct (liftP x (fun c => c1 c = c2 c) (fun c => decide_eq _ (c1 c) (c2 c)))
        as [p|p].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p0 : i y = i x0) =>
match
  p0 as p1 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p1) =
     (y; p1))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p0 : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p0) =
(y; p0)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
c2: forall y : B x, IW I A B i j (j x y)
p: forall c : B x, c1 c = c2 c
Decidable (c1 = c2)
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p0 : i y = i x0) =>
match
  p0 as p1 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p1) =
     (y; p1))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p0 : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p0) =
(y; p0)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
c2: forall y : B x, IW I A B i j (j x y)
p: ~ (forall c : B x, c1 c = c2 c)
Decidable (c1 = c2)
      +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p0 : i y = i x0) =>
match
  p0 as p1 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p1) =
     (y; p1))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p0 : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p0) =
(y; p0)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
c2: forall y : B x, IW I A B i j (j x y)
p: forall c : B x, c1 c = c2 c
Decidable (c1 = c2) left; by apply path_forall.
      +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p0 : i y = i x0) =>
match
  p0 as p1 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p1) =
     (y; p1))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p0 : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p0) =
(y; p0)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
c2: forall y : B x, IW I A B i j (j x y)
p: ~ (forall c : B x, c1 c = c2 c)
Decidable (c1 = c2) right; intro h; by apply p, apD10. }
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c2 (ap getfib_plus r): forall (x0 : A) (c0 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c2 -> c0 = c2
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y : B x, IW I A B i j (j x y)
b: IW I A B i j (i x)
decide_children:= fun c2 : forall y : B x, IW I A B i j (j x y) =>
let d :=
  liftP x (fun c : B x => c1 c = c2 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c2 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c2 c => inl (path_forall c1 c2 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c2 c) =>
     inr ((fun h : c1 = c2 => p (apD10 h)) : c1 <> c2)) n
end: forall c2 : forall y : B x, IW I A B i j (j x y), Decidable (c1 = c2)
Decidable (iw_sup I A B i j x c1 = b)
    snrefine (
      match b in (IW _ _ _ _ _ l)
        return
          forall iy : l = i x,
            Decidable (iw_sup I A B i j x c1
              = paths_rec l (IW I A B i j) b (i x) iy)
      with iw_sup y c2 => fun iy : i y = i x => _ end idpath).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy)
    destruct (fibers_dec (i x) (x ; idpath) (y ; iy)) as [feq|fneq].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy)
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
fneq: (x; 1) <> (y; iy)
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy)
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy) refine (
        match feq in (_ = (y ; iy))
          return forall c2,
            Decidable (iw_sup _ _ _ _ _ x c1
              = paths_rec (i y) (IW I A B i j) (iw_sup _ _ _ _ _ y c2) (i x) iy)
          with idpath => _
        end c2).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
forall (iV := (x; 1)) (y0 := iV.1) (iy0 := iV.2)
(c0 : forall y1 : B y0, IW I A B i j (j y0 y1)),
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 c0) (i x) iy0)
      cbn; intros c3.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
Decidable (iw_sup I A B i j x c1 = iw_sup I A B i j x c3)
      destruct (decide_children c3) as [ceq | cneq].
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
ceq: c1 = c3
Decidable (iw_sup I A B i j x c1 = iw_sup I A B i j x c3)
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
cneq: c1 <> c3
Decidable (iw_sup I A B i j x c1 = iw_sup I A B i j x c3)
      -
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
ceq: c1 = c3
Decidable (iw_sup I A B i j x c1 = iw_sup I A B i j x c3) left; exact (ap _ ceq).
      -
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
cneq: c1 <> c3
Decidable (iw_sup I A B i j x c1 = iw_sup I A B i j x c3) right; intros r; apply cneq.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c))
  (r0 : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c4 (ap getfib_plus r0): forall (x0 : A) (c0 c4 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c4 -> c0 = c4
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
feq: (x; 1) = (y; iy)
c3: forall y0 : B x, IW I A B i j (j x y0)
cneq: c1 <> c3
r: iw_sup I A B i j x c1 = iw_sup I A B i j x c3
c1 = c3
        exact (children_eq x c1 c3 r).
    +
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
fneq: (x; 1) <> (y; iy)
Decidable
  (iw_sup I A B i j x c1 =
   paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy) right; intros r; apply fneq.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
  (p : i y0 = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) i0 p0) =
     (y0; p0))
with
| 1 => 1
end: forall (x0 y0 : A) (children : forall y1 : B y0, IW I A B i j (j y0 y1))
(p : i y0 = i x0),
getfib
  (paths_rec (i y0) (IW I A B i j) (iw_sup I A B i j y0 children) (i x0) p) =
(y0; p)
getfib_plus:= fun (x0 : I) (a : IW I A B i j x0) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c))
  (r0 : iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c0 c3 (ap getfib_plus r0): forall (x0 : A) (c0 c3 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c0 = iw_sup I A B i j x0 c3 -> c0 = c3
decide_eq: forall (l : I) (a b0 : IW I A B i j l), Decidable (a = b0)
x: A
c1: forall y0 : B x, IW I A B i j (j x y0)
b: IW I A B i j (i x)
decide_children:= fun c0 : forall y0 : B x, IW I A B i j (j x y0) =>
let d :=
  liftP x (fun c : B x => c1 c = c0 c)
    (fun c : B x => decide_eq (j x c) (c1 c) (c0 c))
  in
match d with
| inl p =>
    (fun p0 : forall c : B x, c1 c = c0 c => inl (path_forall c1 c0 p0)) p
| inr n =>
    (fun p : ~ (forall c : B x, c1 c = c0 c) =>
     inr ((fun h : c1 = c0 => p (apD10 h)) : c1 <> c0)) n
end: forall c0 : forall y0 : B x, IW I A B i j (j x y0), Decidable (c1 = c0)
y: A
c2: forall y0 : B y, IW I A B i j (j y y0)
iy: i y = i x
fneq: (x; 1) <> (y; iy)
r: iw_sup I A B i j x c1 =
paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y c2) (i x) iy
(x; 1) = (y; iy)
      exact (ap getfib r @ getfib_computes x y c2 iy).
  Defined.

  Definition decidablepaths_iwtype
    : forall x, DecidablePaths (IW I A B i j x).
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
liftP: forall (x : A) (P : B x -> Type),
(forall c : B x, Decidable (P c)) -> Decidable (forall c : B x, P c)
fibers_dec: forall x : I, DecidablePaths (hfiber i x)
children_for:= fun x : A => forall c : B x, IW I A B i j (j x c): A -> Type
getfib:= fun (x : I) (a : IW I A B i j x) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x0 _ => (x0; 1)
end: forall x : I, IW I A B i j x -> hfiber i x
getfib_computes:= fun (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x),
getfib (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x) p) =
(y; p)
getfib_plus:= fun (x : I) (a : IW I A B i j x) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x0 c => ((x0; 1); c)
end: forall x : I, IW I A B i j x -> {f : hfiber i x & children_for f.1}
children_eq:= fun (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c))
  (r : iw_sup I A B i j x c1 = iw_sup I A B i j x c2) =>
inj_right_pair_on (fun f : {x0 : A & i x0 = i x} => children_for f.1) 
  (x; 1) c1 c2 (ap getfib_plus r): forall (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c)),
iw_sup I A B i j x c1 = iw_sup I A B i j x c2 -> c1 = c2
forall x : I, DecidablePaths (IW I A B i j x)
  Proof.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
liftP: forall (x : A) (P : B x -> Type),
(forall c : B x, Decidable (P c)) -> Decidable (forall c : B x, P c)
fibers_dec: forall x : I, DecidablePaths (hfiber i x)
children_for:= fun x : A => forall c : B x, IW I A B i j (j x c): A -> Type
getfib:= fun (x : I) (a : IW I A B i j x) =>
match a in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x0 _ => (x0; 1)
end: forall x : I, IW I A B i j x -> hfiber i x
getfib_computes:= fun (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x),
getfib (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x) p) =
(y; p)
getfib_plus:= fun (x : I) (a : IW I A B i j x) =>
match a in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1} with
| @iw_sup _ _ _ _ _ x0 c => ((x0; 1); c)
end: forall x : I, IW I A B i j x -> {f : hfiber i x & children_for f.1}
children_eq:= fun (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c))
  (r : iw_sup I A B i j x c1 = iw_sup I A B i j x c2) =>
inj_right_pair_on (fun f : {x0 : A & i x0 = i x} => children_for f.1) 
  (x; 1) c1 c2 (ap getfib_plus r): forall (x : A) (c1 c2 : forall c : B x, IW I A B i j (j x c)),
iw_sup I A B i j x c1 = iw_sup I A B i j x c2 -> c1 = c2
forall x : I, DecidablePaths (IW I A B i j x)
    intros x a b.
H: Funext
I, A: Type
B: A -> Type
i: A -> I
j: forall x0 : A, B x0 -> I
liftP: forall (x0 : A) (P : B x0 -> Type),
(forall c : B x0, Decidable (P c)) -> Decidable (forall c : B x0, P c)
fibers_dec: forall x0 : I, DecidablePaths (hfiber i x0)
children_for:= fun x0 : A => forall c : B x0, IW I A B i j (j x0 c): A -> Type
getfib:= fun (x0 : I) (a0 : IW I A B i j x0) =>
match a0 in (IW _ _ _ _ _ i0) return (hfiber i i0) with
| @iw_sup _ _ _ _ _ x1 _ => (x1; 1)
end: forall x0 : I, IW I A B i j x0 -> hfiber i x0
getfib_computes:= fun (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
  (p : i y = i x0) =>
match
  p as p0 in (_ = i0)
  return
    (getfib
       (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) i0 p0) =
     (y; p0))
with
| 1 => 1
end: forall (x0 y : A) (children : forall y0 : B y, IW I A B i j (j y y0))
(p : i y = i x0),
getfib
  (paths_rec (i y) (IW I A B i j) (iw_sup I A B i j y children) (i x0) p) =
(y; p)
getfib_plus:= fun (x0 : I) (a0 : IW I A B i j x0) =>
match
  a0 in (IW _ _ _ _ _ i0) return {f : hfiber i i0 & children_for f.1}
with
| @iw_sup _ _ _ _ _ x1 c => ((x1; 1); c)
end: forall x0 : I, IW I A B i j x0 -> {f : hfiber i x0 & children_for f.1}
children_eq:= fun (x0 : A) (c1 c2 : forall c : B x0, IW I A B i j (j x0 c))
  (r : iw_sup I A B i j x0 c1 = iw_sup I A B i j x0 c2) =>
inj_right_pair_on (fun f : {x1 : A & i x1 = i x0} => children_for f.1)
  (x0; 1) c1 c2 (ap getfib_plus r): forall (x0 : A) (c1 c2 : forall c : B x0, IW I A B i j (j x0 c)),
iw_sup I A B i j x0 c1 = iw_sup I A B i j x0 c2 -> c1 = c2
x: I
a, b: IW I A B i j x
Decidable (a = b)
    apply decide_eq.
  Defined.

End DecidablePaths.