Require Import Basics.
[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
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 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 b : forall x : A, B x, a == b -> 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 b : forall x : A, B x, a == b -> 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 b : forall x : A, B x, a == b -> 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 b : forall x : A, B x, a == b -> 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 i : I, IW' i -> 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 i : I, IW' i -> 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 x : A, B x -> I
P: forall i : I, IW' i -> 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)
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 i : I, IW' i -> 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 i : I, IW' i -> 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 x : A, B x -> I
P: forall i : I, IW' i -> 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)
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 i : I, IW' i -> 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 i : I, IW' i -> 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 i : I, IW' i -> 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)
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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> I
H: Funext
x: I
?f o ?g == idmap
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
?g o ?f == idmap
    {
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 x : A, B x -> I
H: Funext
x: I
forall x : A,
(forall x0 : B x, IW' (j x x0)) ->
(forall c : B x, IW I A B i j (j x c)) ->
IW I A B i j (i x)
      intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a, IW I A B i j (j a c)
IW I A B i j (i a)
      apply iw_sup.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a, IW I A B i j (j a c)
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 x : A, B x -> I
H: Funext
x: I
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a, IW I A B i j (j a c)
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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> I
H: Funext
x: I
forall x : A,
(forall y : B x, IW I A B i j (j x y)) ->
(forall y : B x, IW' (j x y)) -> IW' (i x)
      intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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)
y: B a
IW' (j a y)
      apply c. }
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> I
H: Funext
x: I
forall (x : A)
(i0 : forall y : B x, IW I A B i j (j x y)),
(forall y : B 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)) (j x 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 x y)
      (i0 y)) = i0 y) ->
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)) (i 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)) (i x)
     (iw_sup I A B i j x i0)) = iw_sup I A B i j x i0
      cbn; intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 (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))
  (j a 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 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 x : I, IsIndexedBy x w -> IW I A B i j x)
     (fun (a : A) (b : B a -> W A B)
        (k : forall (b0 : B a) (x : I),
             IsIndexedBy x (b b0) -> IW I A B i j x)
        (x : I)
        (r : (i a = x) *
             (forall c : B a,
              IsIndexedBy (j a c) (b c))) =>
      match
        fst r in (_ = i0) return (IW I A B i j i0)
      with
      | 1 =>
          iw_sup I A B i j a
            (fun y0 : B a => k y0 (j a 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 (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 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 (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 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 x : A, B x -> 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 (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))
  (j a 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 a y)
     (b y)) = b y
(fun y : B a =>
 W_rect A B
   (fun w : W A B =>
    forall x : I, IsIndexedBy x w -> IW I A B i j x)
   (fun (a : A) (b : B a -> W A B)
      (k : forall (b0 : B a) (x : I),
           IsIndexedBy x (b b0) -> IW I A B i j x)
      (x : I)
      (r : (i a = x) *
           (forall c : B a, IsIndexedBy (j a c) (b c)))
    =>
    match
      fst r in (_ = i0) return (IW I A B i j i0)
    with
    | 1 =>
        iw_sup I A B i j a
          (fun y0 : B a => k y0 (j a 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 (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 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 (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 a y) (b y)).2) =
b
      funext y.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 (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))
  (j a 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 a y)
     (b y)) = b y
y: B a
W_rect A B
  (fun w : W A B =>
   forall x : I, IsIndexedBy x w -> IW I A B i j x)
  (fun (a : A) (b : B a -> W A B)
     (k : forall (b0 : B a) (x : I),
          IsIndexedBy x (b b0) -> IW I A B i j x)
     (x : I)
     (r : (i a = x) *
          (forall c : B a, IsIndexedBy (j a c) (b c)))
   =>
   match
     fst r in (_ = i0) return (IW I A B i j i0)
   with
   | 1 =>
       iw_sup I A B i j a
         (fun y : B a => k y (j a y) (snd r y))
   end)
  (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)) (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 (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)) (j a y) (b y)).2 =
b y
      apply c. }
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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 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 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 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 x : A, B x -> I
H: Funext
x: I
y: IW' x
forall (x : A) (y : forall x0 : B x, IW' (j x x0)),
(forall c : B 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))
      (c0 : forall y0 : B a, IW' (j a y0)) =>
    iw_sup' a (fun y0 : B a => c0 y0)) (j x c)
   (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))
         (c0 : forall c0 : B a, IW I A B i j (j a c0))
       => iw_sup I A B i j a (fun y0 : B a => c0 y0))
      (j x c) (y c)) = y c) ->
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)) (i 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)) (i x)
     (iw_sup' x y)) = iw_sup' x y
    cbn; intros a b c.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a,
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))
     (c0 : forall y : B a, IW' (j a y)) =>
   iw_sup' a (fun y : B a => c0 y)) (j a c)
  (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))
        (c0 : forall c0 : B a,
              IW I A B i j (j a c0)) =>
      iw_sup I A B i j a (fun y : B a => c0 y))
     (j a c) (b c)) = b c
iw_sup' a
  (fun y : B a =>
   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 a y)
     (W_rect A B
        (fun w : W A B =>
         forall x : I,
         IsIndexedBy x w -> IW I A B i j x)
        (fun (a : A) (b : B a -> W A B)
           (k : forall (b0 : B a) (x : I),
                IsIndexedBy x (b b0) -> IW I A B i j x)
           (x : I)
           (r : (i a = x) *
                (forall c : B a,
                 IsIndexedBy (j a c) (b c))) =>
         match
           fst r in (_ = i0) return (IW I A B i j i0)
         with
         | 1 =>
             iw_sup I A B i j a
               (fun y0 : B a =>
                k y0 (j a y0) (snd r y0))
         end) (b y).1 (j a y) (b y).2)) = iw_sup' a b
    apply ap.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a,
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))
     (c0 : forall y : B a, IW' (j a y)) =>
   iw_sup' a (fun y : B a => c0 y)) (j a c)
  (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))
        (c0 : forall c0 : B a,
              IW I A B i j (j a c0)) =>
      iw_sup I A B i j a (fun y : B a => c0 y))
     (j a c) (b c)) = b c
(fun y : B a =>
 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 a y)
   (W_rect A B
      (fun w : W A B =>
       forall x : I, IsIndexedBy x w -> IW I A B i j x)
      (fun (a : A) (b : B a -> W A B)
         (k : forall (b0 : B a) (x : I),
              IsIndexedBy x (b b0) -> IW I A B i j x)
         (x : I)
         (r : (i a = x) *
              (forall c : B a,
               IsIndexedBy (j a c) (b c))) =>
       match
         fst r in (_ = i0) return (IW I A B i j i0)
       with
       | 1 =>
           iw_sup I A B i j a
             (fun y0 : B a => k y0 (j a y0) (snd r y0))
       end) (b y).1 (j a y) (b y).2)) = b
    funext d.
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> I
H: Funext
x: I
y: IW' x
a: A
b: forall x0 : B a, IW' (j a x0)
c: forall c : B a,
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))
     (c0 : forall y : B a, IW' (j a y)) =>
   iw_sup' a (fun y : B a => c0 y)) (j a c)
  (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))
        (c0 : forall c0 : B a,
              IW I A B i j (j a c0)) =>
      iw_sup I A B i j a (fun y : B a => c0 y))
     (j a c) (b c)) = b c
d: B a
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)) (j a d)
  (W_rect A B
     (fun w : W A B =>
      forall x : I, IsIndexedBy x w -> IW I A B i j x)
     (fun (a : A) (b : B a -> W A B)
        (k : forall (b0 : B a) (x : I),
             IsIndexedBy x (b b0) -> IW I A B i j x)
        (x : I)
        (r : (i a = x) *
             (forall c : B a,
              IsIndexedBy (j a c) (b c))) =>
      match
        fst r in (_ = i0) return (IW I A B i j i0)
      with
      | 1 =>
          iw_sup I A B i j a
            (fun y : B a => k y (j a y) (snd r y))
      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 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
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 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
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 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
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 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
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y : B' (x; (c1, c2)),
IWPath (j' (x; (c1, c2)) y)
IWPath (i' (x; (c1, c2)))
    unfold IWPath.
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
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y : B' (x; (c1, c2)),
IWPath (j' (x; (c1, c2)) y)
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 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
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y : B' (x; (c1, c2)),
IWPath (j' (x; (c1, c2)) y)
c1 = c2
    funext l.
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
x: A
c1, c2: forall c : B x, IW I A B i j (j x c)
y: forall y : B' (x; (c1, c2)),
IWPath (j' (x; (c1, c2)) y)
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 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
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 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
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 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
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 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
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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)
y: B' e
IWPath (j' e y)
      apply g. }
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
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 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
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 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
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 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
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 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
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 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
x: I
a, b: IW I A B i j x
e: A'
f: forall x : B' e, IWPath (j' e x)
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 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
x: I
a, b: IW I A B i j x
e: A'
f: forall x : B' e, IWPath (j' e x)
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 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
x: I
a, b: IW I A B i j x
e: A'
f: forall x : B' e, IWPath (j' e x)
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 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
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 x : B' e, IWPath (j' e x))
        (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 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
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 x : B' e, IWPath (j' e x))
      (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 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
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 x : B' e, IWPath (j' e x))
        (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 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
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 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)) (x; (a, b))
  (IWPath_ind
     (fun (s : I') (_ : IWPath s) =>
      IW I' A' B' i' j' s)
     (fun (e : A')
        (_ : forall x : B' e, IWPath (j' e x))
        (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))
     (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 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
x: I
a, b: IW I A B i j x
a': A'
b': forall x : B' a', IWPath (j' a' x)
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 x : B' e, IWPath (j' e x))
        (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 x : B' e, IWPath (j' e x))
        (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 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
x: I
a, b: IW I A B i j x
a': A'
b': forall x : B' a', IWPath (j' a' x)
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 x : B' e, IWPath (j' e x))
        (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 x : B' e, IWPath (j' e x))
           (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 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
x: I
a, b: IW I A B i j x
a': A'
b': forall x : B' a', IWPath (j' a' x)
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 x : B' e, IWPath (j' e x))
        (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 x : B' e, IWPath (j' e x))
         (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 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
x: I
a, b: IW I A B i j x
a': A'
b': forall x : B' a', IWPath (j' a' x)
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 x : B' e, IWPath (j' e x))
        (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
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 x : B' e, IWPath (j' e x))
        (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))
     (j' a' c) (b' c)) = b' c
      apply IH. }
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
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 x : B' e, IWPath (j' e x))
      (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 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
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 x : B' e, IWPath (j' e x))
     (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))
  (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 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)) (x; (a, b))
     y) = y
    induction y as [e f IH].
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
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 (e : A')
     (_ : forall x : B' e, IWPath (j' e x))
     (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' e y)
  (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' e y) (f y)) = f y
IWPath_ind
  (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e : A') (_ : forall x : B' e, IWPath (j' e x))
     (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' e)
  (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' 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 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
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 (e : A')
     (_ : forall x : B' e, IWPath (j' e x))
     (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' e y)
  (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' 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 (e : A')
        (_ : forall x : B' e, IWPath (j' e x))
        (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' e y)
     ((fix F
         (y0 : I') (i : IW I' A' B' i' j' y0) {struct
          i} : IWPath y0 :=
         match
           i in (IW _ _ _ _ _ y1) return (IWPath y1)
         with
         | @iw_sup _ _ _ _ _ x i0 =>
             iwpath_sup x
               (fun y1 : B' x => F (j' x y1) (i0 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 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
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 (e : A')
     (_ : forall x : B' e, IWPath (j' e x))
     (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' e y)
  (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' e y) (f y)) = f y
c: B' e
IWPath_ind
  (fun (s : I') (_ : IWPath s) => IW I' A' B' i' j' s)
  (fun (e : A') (_ : forall x : B' e, IWPath (j' e x))
     (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))
  (j' e c)
  ((fix F
      (y : I') (i : IW I' A' B' i' j' y) {struct i} :
        IWPath y :=
      match
        i in (IW _ _ _ _ _ y0) return (IWPath y0)
      with
      | @iw_sup _ _ _ _ _ x i0 =>
          iwpath_sup x
            (fun y0 : B' x => F (j' x y0) (i0 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 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
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 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
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 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
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) (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
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) (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
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) (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
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
chb : 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 chb) 1
    intros x.
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
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 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
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 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
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)
(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 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
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)
(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
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
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)
(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 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 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
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 (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
      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 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
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 a b : IW I A B i j lb,
iw_to_hfiber_index lb a =
adjust_hfiber (iw_to_hfiber_index lb b) 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 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
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 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
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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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
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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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
forall (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
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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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':= ?Goal: forall (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
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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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
forall (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 intros x 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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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
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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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':= 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)
(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
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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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':= 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)
(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
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 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
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 p in (_ = i0)
  return
    (forall (a : IW I A B i j i0)
     (b : IW I A B i j lb),
     iw_to_hfiber_index i0 a =
     adjust_hfiber (iw_to_hfiber_index lb b) p ->
     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)
(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':= 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)
(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
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 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
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 x : A, B x -> 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 x : A, B x -> 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 x : A, B x -> 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
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
y0: IW I A B i j (i x)
y: A
y': forall y0 : B y, IW I A B i j (j y y0)
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 x : A, B x -> 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
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 x : A, B x -> 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
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 x : A, B x -> 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
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 x : A, B x -> 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
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 x : A, B x -> 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
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 (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)
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 (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)
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 (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)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 (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)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 (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)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 (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)
I, A: Type
B: A -> Type
i: A -> I
j: forall x : A, B x -> 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 a : A =>
         functor_prod (iw_sup I A B i j a)
           (iw_sup I A B i j a))) (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) (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
decide_eq: forall (l : I) (a b : IW I A B i j l),
Decidable (a = 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) (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
decide_eq: forall (l : I) (a b : IW I A B i j l),
Decidable (a = 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 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
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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 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
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)
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)
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 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
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)
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)
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 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
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)
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)
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 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
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)
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)
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 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
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)
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)
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)) (y := iV.1) (iy := iV.2)
(c2 : forall y0 : B y, IW I A B i j (j y y0)),
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)
      cbn; intros c3.
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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 y : B x, IW I A B i j (j x y)
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 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
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)
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)
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 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
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)
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)
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 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
x: I
a, b: IW I A B i j x
Decidable (a = b)
    apply decide_eq.
  Defined.

End DecidablePaths.