(** * Sequential colimits *)

(** We present a proof of the conjecture that sequential colimits in HoTT appropriately commute with Σ-types. As a corollary, we characterize the path space of a sequential colimit as a sequential colimit of path spaces. For the written account of these results see https://www.cs.cornell.edu/~ks858/papers/sequential_colimits_homotopy.pdf. *)

Require Import Basics.
[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import Types.
Require Import Diagrams.Diagram.
Require Import Diagrams.Sequence.
Require Import Diagrams.Cocone.
Require Import Colimits.Colimit.
Require Import Spaces.Nat.Core.
Require Import Homotopy.IdentitySystems.

Local Open Scope nat_scope.
Local Open Scope path_scope.

(** [coe] is [transport idmap : (A = B) -> (A -> B)], but is described as the underlying map of an equivalence so that Coq knows that it is an equivalence. *)
Notation coe := (fun p => equiv_fun (equiv_path _ _ p)).
Notation "a ^+" := (@arr sequence_graph _ _ _ 1 a).

(** Mapping spaces into hprops from colimits of sequences can be characterized. *)
Lemma equiv_colim_seq_rec `{Funext} (A : Sequence) (P : Type) `{IsHProp P}
  : (Colimit A -> P) <~> (forall n, A n -> P).
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
(Colimit A -> P) <~>
(forall n : Graph.graph0 sequence_graph, A n -> P)
Proof.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
(Colimit A -> P) <~>
(forall n : Graph.graph0 sequence_graph, A n -> P)
  symmetry.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
(forall n : Graph.graph0 sequence_graph, A n -> P) <~>
(Colimit A -> P)
  refine (equiv_colimit_rec P oE _).
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
(forall n : Graph.graph0 sequence_graph, A n -> P) <~>
Cocone A P
  refine (issig_Cocone _ _ oE _).
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
(forall n : Graph.graph0 sequence_graph, A n -> P) <~>
{H : forall i : Graph.graph0 sequence_graph, A i -> P
&
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun x : A i => H j ((A _f g) x)) == H i}
  symmetry.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
{H : forall i : Graph.graph0 sequence_graph, A i -> P
&
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun x : A i => H j ((A _f g) x)) == H i} <~>
(forall n : Graph.graph0 sequence_graph, A n -> P)
  srapply Build_Equiv.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
{H : forall i : Graph.graph0 sequence_graph, A i -> P
&
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun x : A i => H j ((A _f g) x)) == H i} ->
forall n : Graph.graph0 sequence_graph, A n -> P
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
IsEquiv ?equiv_fun
  1: exact pr1.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
IsEquiv pr1
  exact _.
Defined.

(** If a sequential colimit has maps homotopic to a constant map then the colimit is contractible. *)
Instance contr_colim_seq_into_prop {funext : Funext} (A : Sequence)
  (a : forall n, A n) (H : forall n, const (a n.+1) == A _f idpath)
  : Contr (Colimit A).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
Contr (Colimit A)
Proof.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
Contr (Colimit A)
  transparent assert (B : Sequence).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
Sequence
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= ?Goal: Sequence
Contr (Colimit A)
  {
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
Sequence srapply Build_Sequence.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
nat -> Type
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
forall n : nat, ?X n -> ?X n.+1
    1: exact A.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
forall n : nat, A n -> A n.+1
    intros n.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
n: nat
A n -> A n.+1
    exact (const (a n.+1)). }
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr (Colimit A)
  rapply contr_equiv'.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
?Goal <~> Colimit A
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr ?Goal
  1: rapply equiv_functor_colimit.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
?Goal0 ~d~ A
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr (Colimit ?Goal0)
  1: rapply (equiv_sequence B A).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
B 0 <~> A 0
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (n : Graph.graph0 sequence_graph)
(e : B n <~> A n),
{e' : B n.+1 <~> A n.+1 &
(fun x : B n => (e x) ^+) == (fun x : B n => e' x ^+)}
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr (Colimit B)
  1: reflexivity.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (n : Graph.graph0 sequence_graph)
(e : B n <~> A n),
{e' : B n.+1 <~> A n.+1 &
(fun x : B n => (e x) ^+) == (fun x : B n => e' x ^+)}
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr (Colimit B)
  {
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (n : Graph.graph0 sequence_graph)
(e : B n <~> A n),
{e' : B n.+1 <~> A n.+1 &
(fun x : B n => (e x) ^+) == (fun x : B n => e' x ^+)} intros n e.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n: Graph.graph0 sequence_graph
e: B n <~> A n
{e' : B n.+1 <~> A n.+1 &
(fun x : B n => (e x) ^+) == (fun x : B n => e' x ^+)}
    exists equiv_idmap.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n: Graph.graph0 sequence_graph
e: B n <~> A n
(fun x : B n => (e x) ^+) ==
(fun x : B n => 1%equiv x ^+)
    intros x.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n: Graph.graph0 sequence_graph
e: B n <~> A n
x: B n
(e x) ^+ = 1%equiv x ^+
    symmetry.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n: Graph.graph0 sequence_graph
e: B n <~> A n
x: B n
1%equiv x ^+ = (e x) ^+
    exact (H _ (e x)). }
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Contr (Colimit B)
  srapply Build_Contr.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
Colimit B
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall y : Colimit B, ?center = y
  1: exact (colim (D:=B) 1%nat (a 1%nat)).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall y : Colimit B, colim 1 (a 1) = y
  srapply Colimit_ind.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (i : Graph.graph0 sequence_graph) (x : B i),
colim 1 (a 1) = colim i x
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) 
(x : B i),
transport (paths (colim 1 (a 1))) 
  (colimp i j g x) (?q j ((B _f g) x)) = 
?q i x
  {
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (i : Graph.graph0 sequence_graph) (x : B i),
colim 1 (a 1) = colim i x intros i x.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: Graph.graph0 sequence_graph
x: B i
colim 1 (a 1) = colim i x
    induction i.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
x: B 0
colim 1 (a 1) = colim 0 x
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: nat
x: B i.+1
IHi: forall x : B i, colim 1 (a 1) = colim i x
colim 1 (a 1) = colim i.+1 x
    1: exact (colimp (D:=B) _ _ idpath x).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: nat
x: B i.+1
IHi: forall x : B i, colim 1 (a 1) = colim i x
colim 1 (a 1) = colim i.+1 x
    refine (IHi (a i) @ _).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: nat
x: B i.+1
IHi: forall x : B i, colim 1 (a 1) = colim i x
colim i (a i) = colim i.+1 x
    refine ((colimp (D:=B) _ _ idpath (a i))^ @ _).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: nat
x: B i.+1
IHi: forall x : B i, colim 1 (a 1) = colim i x
colim i.+1 (a i) ^+ = colim i.+1 x
    refine ((colimp (D:=B) _ _ idpath (a i.+1))^ @ _).
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
i: nat
x: B i.+1
IHi: forall x : B i, colim 1 (a 1) = colim i x
colim i.+2 (a i.+1) ^+ = colim i.+1 x
    exact (colimp (D:=B) _ _ idpath x). }
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : B i),
transport (paths (colim 1 (a 1))) (colimp i j g x)
  ((fun (i0 : Graph.graph0 sequence_graph) (x0 : B i0)
    =>
    nat_rect
      (fun i1 : nat =>
       forall x1 : B i1, colim 1 (a 1) = colim i1 x1)
      (fun x1 : B 0 => colimp 0 1 1 x1)
      (fun (i1 : nat)
         (IHi : forall x1 : B i1,
                colim 1 (a 1) = colim i1 x1)
         (x1 : B i1.+1) =>
       IHi (a i1) @
       ((colimp i1 i1.+1 1 (a i1))^ @
        ((colimp i1.+1 i1.+2 1 (a i1.+1))^ @
         colimp i1.+1 i1.+2 1 x1))) i0 x0) j
     ((B _f g) x)) =
(fun (i0 : Graph.graph0 sequence_graph) (x0 : B i0) =>
 nat_rect
   (fun i1 : nat =>
    forall x1 : B i1, colim 1 (a 1) = colim i1 x1)
   (fun x1 : B 0 => colimp 0 1 1 x1)
   (fun (i1 : nat)
      (IHi : forall x1 : B i1,
             colim 1 (a 1) = colim i1 x1)
      (x1 : B i1.+1) =>
    IHi (a i1) @
    ((colimp i1 i1.+1 1 (a i1))^ @
     ((colimp i1.+1 i1.+2 1 (a i1.+1))^ @
      colimp i1.+1 i1.+2 1 x1))) i0 x0) i x
  intros n m [] x.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
transport (paths (colim 1 (a 1))) (colimp n n.+1 1 x)
  (nat_rect
     (fun i : nat =>
      forall x : B i, colim 1 (a 1) = colim i x)
     (fun x : B 0 => colimp 0 1 1 x)
     (fun (i : nat)
        (IHi : forall x : B i,
               colim 1 (a 1) = colim i x) (x : B i.+1)
      =>
      IHi (a i) @
      ((colimp i i.+1 1 (a i))^ @
       ((colimp i.+1 i.+2 1 (a i.+1))^ @
        colimp i.+1 i.+2 1 x))) n.+1 x ^+) =
nat_rect
  (fun i : nat =>
   forall x : B i, colim 1 (a 1) = colim i x)
  (fun x : B 0 => colimp 0 1 1 x)
  (fun (i : nat)
     (IHi : forall x : B i, colim 1 (a 1) = colim i x)
     (x : B i.+1) =>
   IHi (a i) @
   ((colimp i i.+1 1 (a i))^ @
    ((colimp i.+1 i.+2 1 (a i.+1))^ @
     colimp i.+1 i.+2 1 x))) n x
  rewrite transport_paths_FlFr.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
((ap (fun _ : Colimit B => colim 1 (a 1))
    (colimp n n.+1 1 x))^ @
 nat_rect
   (fun i : nat =>
    forall x : B i, colim 1 (a 1) = colim i x)
   (fun x : B 0 => colimp 0 1 1 x)
   (fun (i : nat)
      (IHi : forall x : B i, colim 1 (a 1) = colim i x)
      (x : B i.+1) =>
    IHi (a i) @
    ((colimp i i.+1 1 (a i))^ @
     ((colimp i.+1 i.+2 1 (a i.+1))^ @
      colimp i.+1 i.+2 1 x))) n.+1 x ^+) @
ap idmap (colimp n n.+1 1 x) =
nat_rect
  (fun i : nat =>
   forall x : B i, colim 1 (a 1) = colim i x)
  (fun x : B 0 => colimp 0 1 1 x)
  (fun (i : nat)
     (IHi : forall x : B i, colim 1 (a 1) = colim i x)
     (x : B i.+1) =>
   IHi (a i) @
   ((colimp i i.+1 1 (a i))^ @
    ((colimp i.+1 i.+2 1 (a i.+1))^ @
     colimp i.+1 i.+2 1 x))) n x
  rewrite ap_const.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
(1^ @
 nat_rect
   (fun i : nat =>
    forall x : B i, colim 1 (a 1) = colim i x)
   (fun x : B 0 => colimp 0 1 1 x)
   (fun (i : nat)
      (IHi : forall x : B i, colim 1 (a 1) = colim i x)
      (x : B i.+1) =>
    IHi (a i) @
    ((colimp i i.+1 1 (a i))^ @
     ((colimp i.+1 i.+2 1 (a i.+1))^ @
      colimp i.+1 i.+2 1 x))) n.+1 x ^+) @
ap idmap (colimp n n.+1 1 x) =
nat_rect
  (fun i : nat =>
   forall x : B i, colim 1 (a 1) = colim i x)
  (fun x : B 0 => colimp 0 1 1 x)
  (fun (i : nat)
     (IHi : forall x : B i, colim 1 (a 1) = colim i x)
     (x : B i.+1) =>
   IHi (a i) @
   ((colimp i i.+1 1 (a i))^ @
    ((colimp i.+1 i.+2 1 (a i.+1))^ @
     colimp i.+1 i.+2 1 x))) n x
  rewrite ap_idmap.
funext: Funext
A: Sequence
a: forall n : Graph.graph0 sequence_graph, A n
H: forall n : nat, const (a n.+1) == A _f 1
B:= Build_Sequence A (fun n : nat => const (a n.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
(1^ @
 nat_rect
   (fun i : nat =>
    forall x : B i, colim 1 (a 1) = colim i x)
   (fun x : B 0 => colimp 0 1 1 x)
   (fun (i : nat)
      (IHi : forall x : B i, colim 1 (a 1) = colim i x)
      (x : B i.+1) =>
    IHi (a i) @
    ((colimp i i.+1 1 (a i))^ @
     ((colimp i.+1 i.+2 1 (a i.+1))^ @
      colimp i.+1 i.+2 1 x))) n.+1 x ^+) @
colimp n n.+1 1 x =
nat_rect
  (fun i : nat =>
   forall x : B i, colim 1 (a 1) = colim i x)
  (fun x : B 0 => colimp 0 1 1 x)
  (fun (i : nat)
     (IHi : forall x : B i, colim 1 (a 1) = colim i x)
     (x : B i.+1) =>
   IHi (a i) @
   ((colimp i i.+1 1 (a i))^ @
    ((colimp i.+1 i.+2 1 (a i.+1))^ @
     colimp i.+1 i.+2 1 x))) n x
  destruct n; simpl; hott_simpl.
Qed.

Definition seq_shift_from_zero_by {A : Sequence} (a : A 0) k : A k.
A: Sequence
a: A 0
k: Graph.graph0 sequence_graph
A k
Proof.
A: Sequence
a: A 0
k: Graph.graph0 sequence_graph
A k
  induction k as [ | k q].
A: Sequence
a: A 0
A 0
A: Sequence
a: A 0
k: nat
q: A k
A k.+1
  -
A: Sequence
a: A 0
A 0 exact a.
  -
A: Sequence
a: A 0
k: nat
q: A k
A k.+1 exact q^+.
Defined.

Notation "a ^+ k" := (seq_shift_from_zero_by a k).

(** Shiftings; described in the paragraph after Lemma 3.7. *)
Definition seq_pair_shift {A : Sequence} (x : sig A) : sig A.
A: Sequence
x: {x : _ & A x}
{x : _ & A x}
Proof.
A: Sequence
x: {x : _ & A x}
{x : _ & A x}
  destruct x as [n a]; exact (n.+1; a^+).
Defined.

Definition seq_pair_shift_by {A : Sequence} (x : sig A) (k : nat) : sig A.
A: Sequence
x: {x : _ & A x}
k: nat
{x : _ & A x}
Proof.
A: Sequence
x: {x : _ & A x}
k: nat
{x : _ & A x}
  induction k as [ | k y].
A: Sequence
x: {x : _ & A x}
{x : _ & A x}
A: Sequence
x: {x : _ & A x}
k: nat
y: {x : _ & A x}
{x : _ & A x}
  -
A: Sequence
x: {x : _ & A x}
{x : _ & A x} exact x.
  -
A: Sequence
x: {x : _ & A x}
k: nat
y: {x : _ & A x}
{x : _ & A x} exact (seq_pair_shift y).
Defined.

Notation "x ^++" := (seq_pair_shift x).
Notation "x ^++ k" := (seq_pair_shift_by x k).

Definition seq_pair_shift_assoc {A : Sequence} (x : sig A) (k : nat)
  : (x^++)^++k = x^++(k.+1).
A: Sequence
x: {x : _ & A x}
k: nat
(x ^++) ^++ k = x ^++ (k.+1)
Proof.
A: Sequence
x: {x : _ & A x}
k: nat
(x ^++) ^++ k = x ^++ (k.+1)
  induction k as [ | k q].
A: Sequence
x: {x : _ & A x}
(x ^++) ^++ 0 = x ^++ 1
A: Sequence
x: {x : _ & A x}
k: nat
q: (x ^++) ^++ k = x ^++ (k.+1)
(x ^++) ^++ (k.+1) = x ^++ (k.+2)
  -
A: Sequence
x: {x : _ & A x}
(x ^++) ^++ 0 = x ^++ 1 reflexivity.
  -
A: Sequence
x: {x : _ & A x}
k: nat
q: (x ^++) ^++ k = x ^++ (k.+1)
(x ^++) ^++ (k.+1) = x ^++ (k.+2) exact (ap seq_pair_shift q).
Defined.

Definition seq_shift_pair_from_zero {A : Sequence} (a : A 0) k : (0;a)^++k = (k;a^+k).
A: Sequence
a: A 0
k: nat
(0; a) ^++ k = (k; a ^+ k)
Proof.
A: Sequence
a: A 0
k: nat
(0; a) ^++ k = (k; a ^+ k)
  induction k as [ | k q].
A: Sequence
a: A 0
(0; a) ^++ 0 = (0; a ^+ 0)
A: Sequence
a: A 0
k: nat
q: (0; a) ^++ k = (k; a ^+ k)
(0; a) ^++ (k.+1) = (k.+1; a ^+ (k.+1))
  -
A: Sequence
a: A 0
(0; a) ^++ 0 = (0; a ^+ 0) reflexivity.
  -
A: Sequence
a: A 0
k: nat
q: (0; a) ^++ k = (k; a ^+ k)
(0; a) ^++ (k.+1) = (k.+1; a ^+ (k.+1)) exact (ap seq_pair_shift q).
Defined.

Notation inj A := (@colim sequence_graph A).
Notation glue A := (fun n => @colimp sequence_graph A n n.+1 1).

(** The uniqueness principle for sequential colimits; Lemma 3.3. *)
Definition seq_colimit_uniq {A : Sequence} E (F G : Colimit A -> E)
  (h : forall n, F o inj A n == G o inj A n)
  (H : forall n a, ap F (glue A n a) @ h n a = h n.+1 a^+ @ ap G (glue A n a))
  : F == G.
A: Sequence
E: Type
F, G: Colimit A -> E
h: forall n : Graph.graph0 sequence_graph,
F o inj A n == G o inj A n
H: forall (n : Graph.graph0 sequence_graph)
(a : A n),
ap F (glue A n a) @ h n a =
h n.+1 a ^+ @ ap G (glue A n a)
F == G
Proof.
A: Sequence
E: Type
F, G: Colimit A -> E
h: forall n : Graph.graph0 sequence_graph,
F o inj A n == G o inj A n
H: forall (n : Graph.graph0 sequence_graph)
(a : A n),
ap F (glue A n a) @ h n a =
h n.+1 a ^+ @ ap G (glue A n a)
F == G
  srapply (Colimit_ind _ h); intros n m p a; destruct p.
A: Sequence
E: Type
F, G: Colimit A -> E
h: forall n : Graph.graph0 sequence_graph,
F o inj A n == G o inj A n
H: forall (n : Graph.graph0 sequence_graph)
(a : A n),
ap F (glue A n a) @ h n a =
h n.+1 a ^+ @ ap G (glue A n a)
n: Graph.graph0 sequence_graph
a: A n
transport (fun w : Colimit A => F w = G w)
  (colimp n n.+1 1 a) (h n.+1 a ^+) = h n a
  generalize (H n a); generalize (h n a); destruct (glue A n a).
A: Sequence
E: Type
F, G: Colimit A -> E
h: forall n : Graph.graph0 sequence_graph,
F o inj A n == G o inj A n
H: forall (n : Graph.graph0 sequence_graph)
(a : A n),
ap F (glue A n a) @ h n a =
h n.+1 a ^+ @ ap G (glue A n a)
n: Graph.graph0 sequence_graph
a: A n
forall p : F (inj A n.+1 a ^+) = G (inj A n.+1 a ^+),
ap F 1 @ p = h n.+1 a ^+ @ ap G 1 ->
transport (fun w : Colimit A => F w = G w) 1
  (h n.+1 a ^+) = p
  intros p q; srefine ((concat_p1 _)^ @ _); srefine (_ @ (concat_1p _)); exact q^.
Defined.

(** The successor sequence from Lemma 3.6. *)
Definition succ_seq (A : Sequence) : Sequence
  := Build_Sequence (fun k => A k.+1) (fun k a => a^+).

(** The shifted sequence from Lemma 3.7. *)
Definition shift_seq (A : Sequence) n : Sequence
  := Build_Sequence (fun k => A (k+n)%nat) (fun k a => a^+).

(** The canonical equivalence between the colimit of the successor sequence and the colimit of the original sequence; Lemma 3.6. *)
Definition colim_succ_seq_to_colim_seq A : Colimit (succ_seq A) -> Colimit A.
A: Sequence
Colimit (succ_seq A) -> Colimit A
Proof.
A: Sequence
Colimit (succ_seq A) -> Colimit A
  srapply Colimit_rec; srapply Build_Cocone.
A: Sequence
forall i : Graph.graph0 sequence_graph,
succ_seq A i -> Colimit A
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o (succ_seq A) _f g == ?legs i
  +
A: Sequence
forall i : Graph.graph0 sequence_graph,
succ_seq A i -> Colimit A exact (fun n a => inj _ n.+1 a).
  +
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (n : Graph.graph0 sequence_graph)
   (a : succ_seq A n) => inj A n.+1 a) j
o (succ_seq A) _f g ==
(fun (n : Graph.graph0 sequence_graph)
   (a : succ_seq A n) => inj A n.+1 a) i intros n m p; destruct p; exact (glue A n.+1).
Defined.

Definition colim_succ_seq_to_colim_seq_beta_glue A n a
  : ap (colim_succ_seq_to_colim_seq A) (glue (succ_seq A) n a) = glue A (n.+1) a.
A: Sequence
n: Graph.graph0 sequence_graph
a: succ_seq A n
ap (colim_succ_seq_to_colim_seq A)
  (glue (succ_seq A) n a) = glue A n.+1 a
Proof.
A: Sequence
n: Graph.graph0 sequence_graph
a: succ_seq A n
ap (colim_succ_seq_to_colim_seq A)
  (glue (succ_seq A) n a) = glue A n.+1 a
  srapply Colimit_rec_beta_colimp.
Defined.

Definition colim_succ_seq_to_colim_seq_ap_inj A n (a1 a2 : succ_seq A n) (p : a1 = a2)
  : ap (colim_succ_seq_to_colim_seq A) (ap (inj _ n) p) = ap (inj _ n.+1) p.
A: Sequence
n: Graph.graph0 sequence_graph
a1, a2: succ_seq A n
p: a1 = a2
ap (colim_succ_seq_to_colim_seq A)
  (ap (inj (succ_seq A) n) p) = ap (inj A n.+1) p
Proof.
A: Sequence
n: Graph.graph0 sequence_graph
a1, a2: succ_seq A n
p: a1 = a2
ap (colim_succ_seq_to_colim_seq A)
  (ap (inj (succ_seq A) n) p) = ap (inj A n.+1) p
  destruct p; reflexivity.
Defined.

Instance isequiv_colim_succ_seq_to_colim_seq A
  : IsEquiv (colim_succ_seq_to_colim_seq A).
A: Sequence
IsEquiv (colim_succ_seq_to_colim_seq A)
Proof.
A: Sequence
IsEquiv (colim_succ_seq_to_colim_seq A)
  srapply isequiv_adjointify.
A: Sequence
Colimit A -> Colimit (succ_seq A)
A: Sequence
colim_succ_seq_to_colim_seq A o ?g == idmap
A: Sequence
?g o colim_succ_seq_to_colim_seq A == idmap
  +
A: Sequence
Colimit A -> Colimit (succ_seq A) srapply Colimit_rec; srapply Build_Cocone.
A: Sequence
forall i : Graph.graph0 sequence_graph,
A i -> Colimit (succ_seq A)
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o A _f g == ?legs i
    *
A: Sequence
forall i : Graph.graph0 sequence_graph,
A i -> Colimit (succ_seq A) exact (fun n a => inj (succ_seq A) n a^+).
    *
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (n : Graph.graph0 sequence_graph) (a : A n) =>
 inj (succ_seq A) n a ^+) j o A _f g ==
(fun (n : Graph.graph0 sequence_graph) (a : A n) =>
 inj (succ_seq A) n a ^+) i intros n m p a; destruct p; exact (glue (succ_seq A) n a^+).
  +
A: Sequence
colim_succ_seq_to_colim_seq A
o Colimit_rec (Colimit (succ_seq A))
    {|
      legs :=
        fun (n : Graph.graph0 sequence_graph)
          (a : A n) => inj (succ_seq A) n a ^+;
      legs_comm :=
        fun (n m : Graph.graph0 sequence_graph)
          (p : Graph.graph1 sequence_graph n m) =>
        (fun a : A n =>
         match
           p as p0 in (_ = n0)
           return
             (inj (succ_seq A) n0 ((A _f p0) a) ^+ =
              inj (succ_seq A) n a ^+)
         with
         | 1 => glue (succ_seq A) n a ^+
         end)
        :
        (fun (n0 : Graph.graph0 sequence_graph)
           (a : A n0) => inj (succ_seq A) n0 a ^+) m
        o A _f p ==
        (fun (n0 : Graph.graph0 sequence_graph)
           (a : A n0) => inj (succ_seq A) n0 a ^+) n
    |} == idmap srapply seq_colimit_uniq.
A: Sequence
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit A =>
 colim_succ_seq_to_colim_seq A
   (Colimit_rec (Colimit (succ_seq A))
      {|
        legs :=
          fun (n0 : Graph.graph0 sequence_graph)
            (a : A n0) => inj (succ_seq A) n0 a ^+;
        legs_comm :=
          fun (n0 m : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph n0 m) =>
          (fun a : A n0 =>
           match
             p as p0 in (_ = n1)
             return
               (inj (succ_seq A) n1 ((A _f p0) a) ^+ =
                inj (succ_seq A) n0 a ^+)
           with
           | 1 => glue (succ_seq A) n0 a ^+
           end)
          :
          (fun (n1 : Graph.graph0 sequence_graph)
             (a : A n1) => inj (succ_seq A) n1 a ^+) m
          o A _f p ==
          (fun (n1 : Graph.graph0 sequence_graph)
             (a : A n1) => inj (succ_seq A) n1 a ^+)
            n0
      |} x)) o inj A n == idmap o inj A n
A: Sequence
forall (n : Graph.graph0 sequence_graph) (a : A n),
ap
  (fun x : Colimit A =>
   colim_succ_seq_to_colim_seq A
     (Colimit_rec (Colimit (succ_seq A))
        {|
          legs :=
            fun (n0 : Graph.graph0 sequence_graph)
              (a0 : A n0) => inj (succ_seq A) n0 a0 ^+;
          legs_comm :=
            fun (n0 m : Graph.graph0 sequence_graph)
              (p : Graph.graph1 sequence_graph n0 m)
            =>
            (fun a0 : A n0 =>
             match
               p as p0 in (_ = n1)
               return
                 (inj (succ_seq A) n1 ((...) a0) ^+ =
                  inj (succ_seq A) n0 a0 ^+)
             with
             | 1 => glue (succ_seq A) n0 a0 ^+
             end)
            :
            (fun (n1 : Graph.graph0 sequence_graph)
               (a0 : A n1) =>
             inj (succ_seq A) n1 a0 ^+) m o A _f p ==
            (fun (n1 : Graph.graph0 sequence_graph)
               (a0 : A n1) =>
             inj (succ_seq A) n1 a0 ^+) n0
        |} x)) (glue A n a) @ ?h n a =
?h n.+1 a ^+ @ ap idmap (glue A n a)
    *
A: Sequence
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit A =>
 colim_succ_seq_to_colim_seq A
   (Colimit_rec (Colimit (succ_seq A))
      {|
        legs :=
          fun (n0 : Graph.graph0 sequence_graph)
            (a : A n0) => inj (succ_seq A) n0 a ^+;
        legs_comm :=
          fun (n0 m : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph n0 m) =>
          (fun a : A n0 =>
           match
             p as p0 in (_ = n1)
             return
               (inj (succ_seq A) n1 ((A _f p0) a) ^+ =
                inj (succ_seq A) n0 a ^+)
           with
           | 1 => glue (succ_seq A) n0 a ^+
           end)
          :
          (fun (n1 : Graph.graph0 sequence_graph)
             (a : A n1) => inj (succ_seq A) n1 a ^+) m
          o A _f p ==
          (fun (n1 : Graph.graph0 sequence_graph)
             (a : A n1) => inj (succ_seq A) n1 a ^+)
            n0
      |} x)) o inj A n == idmap o inj A n exact (fun n a => glue _ n a).
    *
A: Sequence
forall (n : Graph.graph0 sequence_graph) (a : A n),
ap
  (fun x : Colimit A =>
   colim_succ_seq_to_colim_seq A
     (Colimit_rec (Colimit (succ_seq A))
        {|
          legs :=
            fun (n0 : Graph.graph0 sequence_graph)
              (a0 : A n0) => inj (succ_seq A) n0 a0 ^+;
          legs_comm :=
            fun (n0 m : Graph.graph0 sequence_graph)
              (p : Graph.graph1 sequence_graph n0 m)
            =>
            (fun a0 : A n0 =>
             match
               p as p0 in (_ = n1)
               return
                 (inj (succ_seq A) n1 ((...) a0) ^+ =
                  inj (succ_seq A) n0 a0 ^+)
             with
             | 1 => glue (succ_seq A) n0 a0 ^+
             end)
            :
            (fun (n1 : Graph.graph0 sequence_graph)
               (a0 : A n1) =>
             inj (succ_seq A) n1 a0 ^+) m o A _f p ==
            (fun (n1 : Graph.graph0 sequence_graph)
               (a0 : A n1) =>
             inj (succ_seq A) n1 a0 ^+) n0
        |} x)) (glue A n a) @
(fun (n0 : Graph.graph0 sequence_graph) (a0 : A n0) =>
 glue A n0 a0) n a =
(fun (n0 : Graph.graph0 sequence_graph) (a0 : A n0) =>
 glue A n0 a0) n.+1 a ^+ @ ap idmap (glue A n a) intros n a; rewrite ap_idmap, ap_compose, Colimit_rec_beta_colimp.
A: Sequence
n: Graph.graph0 sequence_graph
a: A n
ap (colim_succ_seq_to_colim_seq A)
  (legs_comm
     {|
       legs :=
         fun (n : Graph.graph0 sequence_graph)
           (a : A n) => inj (succ_seq A) n a ^+;
       legs_comm :=
         fun (n m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n m)
           (a : A n) =>
         match
           p as p0 in (_ = n0)
           return
             (inj (succ_seq A) n0 ((A _f p0) a) ^+ =
              inj (succ_seq A) n a ^+)
         with
         | 1 => colimp n n.+1 1 a ^+
         end
     |} n n.+1 1 a) @ colimp n n.+1 1 a =
colimp n.+1 n.+2 1 a ^+ @ colimp n n.+1 1 a
      rewrite colim_succ_seq_to_colim_seq_beta_glue; reflexivity.
  +
A: Sequence
Colimit_rec (Colimit (succ_seq A))
  {|
    legs :=
      fun (n : Graph.graph0 sequence_graph) (a : A n)
      => inj (succ_seq A) n a ^+;
    legs_comm :=
      fun (n m : Graph.graph0 sequence_graph)
        (p : Graph.graph1 sequence_graph n m) =>
      (fun a : A n =>
       match
         p as p0 in (_ = n0)
         return
           (inj (succ_seq A) n0 ((A _f p0) a) ^+ =
            inj (succ_seq A) n a ^+)
       with
       | 1 => glue (succ_seq A) n a ^+
       end)
      :
      (fun (n0 : Graph.graph0 sequence_graph)
         (a : A n0) => inj (succ_seq A) n0 a ^+) m
      o A _f p ==
      (fun (n0 : Graph.graph0 sequence_graph)
         (a : A n0) => inj (succ_seq A) n0 a ^+) n
  |} o colim_succ_seq_to_colim_seq A == idmap srapply seq_colimit_uniq.
A: Sequence
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (succ_seq A) =>
 Colimit_rec (Colimit (succ_seq A))
   {|
     legs :=
       fun (n0 : Graph.graph0 sequence_graph)
         (a : A n0) => inj (succ_seq A) n0 a ^+;
     legs_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       (fun a : A n0 =>
        match
          p as p0 in (_ = n1)
          return
            (inj (succ_seq A) n1 ((A _f p0) a) ^+ =
             inj (succ_seq A) n0 a ^+)
        with
        | 1 => glue (succ_seq A) n0 a ^+
        end)
       :
       (fun (n1 : Graph.graph0 sequence_graph)
          (a : A n1) => inj (succ_seq A) n1 a ^+) m
       o A _f p ==
       (fun (n1 : Graph.graph0 sequence_graph)
          (a : A n1) => inj (succ_seq A) n1 a ^+) n0
   |} (colim_succ_seq_to_colim_seq A x))
o inj (succ_seq A) n == idmap o inj (succ_seq A) n
A: Sequence
forall (n : Graph.graph0 sequence_graph)
(a : succ_seq A n),
ap
  (fun x : Colimit (succ_seq A) =>
   Colimit_rec (Colimit (succ_seq A))
     {|
       legs :=
         fun (n0 : Graph.graph0 sequence_graph)
           (a0 : A n0) => inj (succ_seq A) n0 a0 ^+;
       legs_comm :=
         fun (n0 m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n0 m) =>
         (fun a0 : A n0 =>
          match
            p as p0 in (_ = n1)
            return
              (inj (succ_seq A) n1 ((A _f p0) a0) ^+ =
               inj (succ_seq A) n0 a0 ^+)
          with
          | 1 => glue (succ_seq A) n0 a0 ^+
          end)
         :
         (fun (n1 : Graph.graph0 sequence_graph)
            (a0 : A n1) => inj (succ_seq A) n1 a0 ^+)
           m o A _f p ==
         (fun (n1 : Graph.graph0 sequence_graph)
            (a0 : A n1) => inj (succ_seq A) n1 a0 ^+)
           n0
     |} (colim_succ_seq_to_colim_seq A x))
  (glue (succ_seq A) n a) @ ?h n a =
?h n.+1 a ^+ @ ap idmap (glue (succ_seq A) n a)
    *
A: Sequence
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (succ_seq A) =>
 Colimit_rec (Colimit (succ_seq A))
   {|
     legs :=
       fun (n0 : Graph.graph0 sequence_graph)
         (a : A n0) => inj (succ_seq A) n0 a ^+;
     legs_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       (fun a : A n0 =>
        match
          p as p0 in (_ = n1)
          return
            (inj (succ_seq A) n1 ((A _f p0) a) ^+ =
             inj (succ_seq A) n0 a ^+)
        with
        | 1 => glue (succ_seq A) n0 a ^+
        end)
       :
       (fun (n1 : Graph.graph0 sequence_graph)
          (a : A n1) => inj (succ_seq A) n1 a ^+) m
       o A _f p ==
       (fun (n1 : Graph.graph0 sequence_graph)
          (a : A n1) => inj (succ_seq A) n1 a ^+) n0
   |} (colim_succ_seq_to_colim_seq A x))
o inj (succ_seq A) n == idmap o inj (succ_seq A) n exact (fun n a => glue _ n a).
    *
A: Sequence
forall (n : Graph.graph0 sequence_graph)
(a : succ_seq A n),
ap
  (fun x : Colimit (succ_seq A) =>
   Colimit_rec (Colimit (succ_seq A))
     {|
       legs :=
         fun (n0 : Graph.graph0 sequence_graph)
           (a0 : A n0) => inj (succ_seq A) n0 a0 ^+;
       legs_comm :=
         fun (n0 m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n0 m) =>
         (fun a0 : A n0 =>
          match
            p as p0 in (_ = n1)
            return
              (inj (succ_seq A) n1 ((A _f p0) a0) ^+ =
               inj (succ_seq A) n0 a0 ^+)
          with
          | 1 => glue (succ_seq A) n0 a0 ^+
          end)
         :
         (fun (n1 : Graph.graph0 sequence_graph)
            (a0 : A n1) => inj (succ_seq A) n1 a0 ^+)
           m o A _f p ==
         (fun (n1 : Graph.graph0 sequence_graph)
            (a0 : A n1) => inj (succ_seq A) n1 a0 ^+)
           n0
     |} (colim_succ_seq_to_colim_seq A x))
  (glue (succ_seq A) n a) @
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : succ_seq A n0) => glue (succ_seq A) n0 a0) n
  a =
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : succ_seq A n0) => glue (succ_seq A) n0 a0)
  n.+1 a ^+ @ ap idmap (glue (succ_seq A) n a) intros n a; rewrite ap_idmap, ap_compose, Colimit_rec_beta_colimp.
A: Sequence
n: Graph.graph0 sequence_graph
a: succ_seq A n
ap
  (Colimit_rec (Colimit (succ_seq A))
     {|
       legs :=
         fun (n : Graph.graph0 sequence_graph)
           (a : A n) => inj (succ_seq A) n a ^+;
       legs_comm :=
         fun (n m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n m)
           (a : A n) =>
         match
           p as p0 in (_ = n0)
           return
             (inj (succ_seq A) n0 ((A _f p0) a) ^+ =
              inj (succ_seq A) n a ^+)
         with
         | 1 => colimp n n.+1 1 a ^+
         end
     |})
  (legs_comm
     {|
       legs :=
         fun (n : Graph.graph0 sequence_graph)
           (a : succ_seq A n) => inj A n.+1 a;
       legs_comm :=
         fun (n m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n m) =>
         match
           p as p0 in (_ = n0)
           return
             ((fun x : succ_seq A n =>
               inj A n0.+1 (((succ_seq A) _f p0) x)) ==
              (fun a : succ_seq A n => inj A n.+1 a))
         with
         | 1 => colimp n.+1 n.+2 1
         end
     |} n n.+1 1 a) @ colimp n n.+1 1 a =
colimp n.+1 n.+2 1 a ^+ @ colimp n n.+1 1 a
      rewrite (@Colimit_rec_beta_colimp _ A _ _ _ _ 1); reflexivity.
Defined.

Definition equiv_colim_succ_seq_to_colim_seq A : Colimit (succ_seq A) <~> Colimit A
  := Build_Equiv _ _ (colim_succ_seq_to_colim_seq A) _.

(** The canonical equivalence between the colimit of the shifted sequence and the colimit of the original sequence; Lemma 3.6. *)
Definition colim_shift_seq_to_colim_seq A n : Colimit (shift_seq A n) -> Colimit A.
A: Sequence
n: nat
Colimit (shift_seq A n) -> Colimit A
Proof.
A: Sequence
n: nat
Colimit (shift_seq A n) -> Colimit A
  srapply Colimit_rec; srapply Build_Cocone.
A: Sequence
n: nat
forall i : Graph.graph0 sequence_graph,
shift_seq A n i -> Colimit A
A: Sequence
n: nat
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o (shift_seq A n) _f g == ?legs i
  +
A: Sequence
n: nat
forall i : Graph.graph0 sequence_graph,
shift_seq A n i -> Colimit A exact (fun k a => inj A (k+n)%nat a).
  +
A: Sequence
n: nat
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (k : Graph.graph0 sequence_graph)
   (a : shift_seq A n k) => inj A (k + n) a) j
o (shift_seq A n) _f g ==
(fun (k : Graph.graph0 sequence_graph)
   (a : shift_seq A n k) => inj A (k + n) a) i intros k l p; destruct p; exact (glue A (k+n)%nat).
Defined.

Definition colim_shift_seq_to_colim_seq_beta_glue A n k a
  : ap (colim_shift_seq_to_colim_seq A n) (glue (shift_seq A n) k a) = glue A (k+n)%nat a.
A: Sequence
n: nat
k: Graph.graph0 sequence_graph
a: shift_seq A n k
ap (colim_shift_seq_to_colim_seq A n)
  (glue (shift_seq A n) k a) = glue A (k + n) a
Proof.
A: Sequence
n: nat
k: Graph.graph0 sequence_graph
a: shift_seq A n k
ap (colim_shift_seq_to_colim_seq A n)
  (glue (shift_seq A n) k a) = glue A (k + n) a
  srapply Colimit_rec_beta_colimp.
Defined.

Definition colim_shift_seq_to_colim_seq_ap_inj A n k (a1 a2 : shift_seq A n k) (p : a1 = a2)
  : ap (colim_shift_seq_to_colim_seq A n) (ap (inj _ k) p) = ap (inj _ (k+n)%nat) p.
A: Sequence
n: nat
k: Graph.graph0 sequence_graph
a1, a2: shift_seq A n k
p: a1 = a2
ap (colim_shift_seq_to_colim_seq A n)
  (ap (inj (shift_seq A n) k) p) =
ap (inj A (k + n)) p
Proof.
A: Sequence
n: nat
k: Graph.graph0 sequence_graph
a1, a2: shift_seq A n k
p: a1 = a2
ap (colim_shift_seq_to_colim_seq A n)
  (ap (inj (shift_seq A n) k) p) =
ap (inj A (k + n)) p
  destruct p; reflexivity.
Defined.

Local Definition J {X Y Z} {x1 x2 : X} {y} {I : forall x, Y x -> Z} (p : x2 = x1)
  : I x2 y = I x1 (coe (ap Y p) y).
X: Type
Y: X -> Type
Z: Type
x1, x2: X
y: Y x2
I: forall x : X, Y x -> Z
p: x2 = x1
I x2 y = I x1 (coe (ap Y p) y)
Proof.
X: Type
Y: X -> Type
Z: Type
x1, x2: X
y: Y x2
I: forall x : X, Y x -> Z
p: x2 = x1
I x2 y = I x1 (coe (ap Y p) y)
  destruct p; reflexivity.
Defined.

Local Definition K {X Y} {x1 x2 : X} {y} F G (p : x1 = x2) :
  G x2 (coe (ap Y p) y) = coe (ap Y (ap F p)) (G x1 y).
X: Type
Y: X -> Type
x1, x2: X
y: Y x1
F: X -> X
G: forall x : X, Y x -> Y (F x)
p: x1 = x2
G x2 (coe (ap Y p) y) = coe (ap Y (ap F p)) (G x1 y)
Proof.
X: Type
Y: X -> Type
x1, x2: X
y: Y x1
F: X -> X
G: forall x : X, Y x -> Y (F x)
p: x1 = x2
G x2 (coe (ap Y p) y) = coe (ap Y (ap F p)) (G x1 y)
  destruct p; reflexivity.
Defined.

Local Definition L {X Y Z} {x1 x2 : X} {y} {F G} {I : forall x, Y x -> Z} {p : x2 = x1}
  (Q : forall x y, I (F x) (G x y) = I x y)
  : Q x2 y @ J p =
    J (ap F p) @ (ap (I (F x1)) (K F G p)^ @
    Q x1 (coe (ap Y p) y)).
X: Type
Y: X -> Type
Z: Type
x1, x2: X
y: Y x2
F: X -> X
G: forall x : X, Y x -> Y (F x)
I: forall x : X, Y x -> Z
p: x2 = x1
Q: forall (x : X) (y : Y x), I (F x) (G x y) = I x y
Q x2 y @ J p =
J (ap F p) @
(ap (I (F x1)) (K F G p)^ @ Q x1 (coe (ap Y p) y))
Proof.
X: Type
Y: X -> Type
Z: Type
x1, x2: X
y: Y x2
F: X -> X
G: forall x : X, Y x -> Y (F x)
I: forall x : X, Y x -> Z
p: x2 = x1
Q: forall (x : X) (y : Y x), I (F x) (G x y) = I x y
Q x2 y @ J p =
J (ap F p) @
(ap (I (F x1)) (K F G p)^ @ Q x1 (coe (ap Y p) y))
  destruct p; cbn.
X: Type
Y: X -> Type
Z: Type
x2: X
y: Y x2
F: X -> X
G: forall x : X, Y x -> Y (F x)
I: forall x : X, Y x -> Z
Q: forall (x : X) (y : Y x), I (F x) (G x y) = I x y
Q x2 y @ 1 = 1 @ (1 @ Q x2 y)
  apply equiv_p1_1q.
X: Type
Y: X -> Type
Z: Type
x2: X
y: Y x2
F: X -> X
G: forall x : X, Y x -> Y (F x)
I: forall x : X, Y x -> Z
Q: forall (x : X) (y : Y x), I (F x) (G x y) = I x y
Q x2 y = 1 @ Q x2 y
  symmetry; apply concat_1p.
Defined.

Instance isequiv_colim_shift_seq_to_colim_seq `{Funext} A n
  : IsEquiv (colim_shift_seq_to_colim_seq A n).
H: Funext
A: Sequence
n: nat
IsEquiv (colim_shift_seq_to_colim_seq A n)
Proof.
H: Funext
A: Sequence
n: nat
IsEquiv (colim_shift_seq_to_colim_seq A n)
  induction n as [ | n e]; srapply isequiv_homotopic'.
H: Funext
A: Sequence
Colimit (shift_seq A 0) <~> Colimit A
H: Funext
A: Sequence
?f == colim_shift_seq_to_colim_seq A 0
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (shift_seq A n.+1) <~> Colimit A
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
?f0 == colim_shift_seq_to_colim_seq A n.+1
  -
H: Funext
A: Sequence
Colimit (shift_seq A 0) <~> Colimit A srapply equiv_functor_colimit; srapply Build_diagram_equiv.
H: Funext
A: Sequence
DiagramMap (shift_seq A 0) A
H: Funext
A: Sequence
forall i : Graph.graph0 sequence_graph, IsEquiv (?m i)
    +
H: Funext
A: Sequence
DiagramMap (shift_seq A 0) A srapply Build_DiagramMap.
H: Funext
A: Sequence
forall i : Graph.graph0 sequence_graph,
shift_seq A 0 i -> A i
H: Funext
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : shift_seq A 0 i),
(A _f g) (?DiagramMap_obj i x) =
?DiagramMap_obj j (((shift_seq A 0) _f g) x)
      *
H: Funext
A: Sequence
forall i : Graph.graph0 sequence_graph,
shift_seq A 0 i -> A i exact (fun k => coe (ap A (nat_add_zero_r k))).
      *
H: Funext
A: Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : shift_seq A 0 i),
(A _f g)
  ((fun k : Graph.graph0 sequence_graph =>
    coe (ap A (nat_add_zero_r k))) i x) =
(fun k : Graph.graph0 sequence_graph =>
 coe (ap A (nat_add_zero_r k))) j
  (((shift_seq A 0) _f g) x) intros k l p a; destruct p.
H: Funext
A: Sequence
k: Graph.graph0 sequence_graph
a: shift_seq A 0 k
(equiv_path (A (k + 0)) (A k)
   (ap A (nat_add_zero_r k)) a) ^+ =
equiv_path (A (k.+1 + 0)) (A k.+1)
  (ap A (nat_add_zero_r k.+1)) a ^+ exact (K S (fun n a => a^+) _).
    +
H: Funext
A: Sequence
forall i : Graph.graph0 sequence_graph,
IsEquiv
  ({|
     DiagramMap_obj :=
       fun k : Graph.graph0 sequence_graph =>
       coe (ap A (nat_add_zero_r k));
     DiagramMap_comm :=
       fun (k l : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph k l)
         (a : shift_seq A 0 k) =>
       match
         p as p0 in (_ = n)
         return
           ((A _f p0)
              (equiv_path (A (k + 0)) (A k)
                 (ap A (nat_add_zero_r k)) a) =
            equiv_path (A (n + 0)) (A n)
              (ap A (nat_add_zero_r n))
              (((shift_seq A 0) _f p0) a))
       with
       | 1 =>
           K S (fun (n : nat) (a0 : A n) => a0 ^+)
             (nat_add_zero_r k)
       end
   |} i) exact _.
  -
H: Funext
A: Sequence
equiv_functor_colimit
  {|
    diag_equiv_map :=
      {|
        DiagramMap_obj :=
          fun k : Graph.graph0 sequence_graph =>
          coe (ap A (nat_add_zero_r k));
        DiagramMap_comm :=
          fun (k l : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph k l)
            (a : shift_seq A 0 k) =>
          match
            p as p0 in (_ = n)
            return
              ((A _f p0)
                 (equiv_path (A (k + 0)) (A k)
                    (ap A (nat_add_zero_r k)) a) =
               equiv_path (A (n + 0)) (A n)
                 (ap A (nat_add_zero_r n))
                 (((shift_seq A 0) _f p0) a))
          with
          | 1 =>
              K S (fun (n : nat) (a0 : A n) => a0 ^+)
                (nat_add_zero_r k)
          end
      |};
    diag_equiv_isequiv :=
      fun i : Graph.graph0 sequence_graph =>
      equiv_isequiv
        (equiv_path (A (i + 0)) (A i)
           (ap A (nat_add_zero_r i)))
  |} (iscolimit_colimit (shift_seq A 0))
  (iscolimit_colimit A) ==
colim_shift_seq_to_colim_seq A 0 symmetry; srapply seq_colimit_uniq.
H: Funext
A: Sequence
forall n : Graph.graph0 sequence_graph,
colim_shift_seq_to_colim_seq A 0
o inj (shift_seq A 0) n ==
equiv_functor_colimit
  {|
    diag_equiv_map :=
      {|
        DiagramMap_obj :=
          fun k : Graph.graph0 sequence_graph =>
          coe (ap A (nat_add_zero_r k));
        DiagramMap_comm :=
          fun (k l : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph k l)
            (a : shift_seq A 0 k) =>
          match
            p as p0 in (_ = n0)
            return
              ((A _f p0)
                 (equiv_path (A (k + 0)) (A k)
                    (ap A (nat_add_zero_r k)) a) =
               equiv_path (A (n0 + 0)) (A n0)
                 (ap A (nat_add_zero_r n0))
                 (((shift_seq A 0) _f p0) a))
          with
          | 1 =>
              K S
                (fun (n0 : nat) (a0 : A n0) => a0 ^+)
                (nat_add_zero_r k)
          end
      |};
    diag_equiv_isequiv :=
      fun i : Graph.graph0 sequence_graph =>
      equiv_isequiv
        (equiv_path (A (i + 0)) (A i)
           (ap A (nat_add_zero_r i)))
  |} (iscolimit_colimit (shift_seq A 0))
  (iscolimit_colimit A) o inj (shift_seq A 0) n
H: Funext
A: Sequence
forall (n : Graph.graph0 sequence_graph)
(a : shift_seq A 0 n),
ap (colim_shift_seq_to_colim_seq A 0)
  (glue (shift_seq A 0) n a) @ ?h0 n a =
?h0 n.+1 a ^+ @
ap
  (equiv_functor_colimit
     {|
       diag_equiv_map :=
         {|
           DiagramMap_obj :=
             fun k : Graph.graph0 sequence_graph =>
             coe (ap A (nat_add_zero_r k));
           DiagramMap_comm :=
             fun (k l : Graph.graph0 sequence_graph)
               (p : Graph.graph1 sequence_graph k l)
               (a0 : shift_seq A 0 k) =>
             match
               p as p0 in (_ = n0)
               return
                 ((A _f p0)
                    (equiv_path (A (k + 0)) (A k)
                       (ap A (nat_add_zero_r k)) a0) =
                  equiv_path (A (n0 + 0)) (A n0)
                    (ap A (nat_add_zero_r n0))
                    (((shift_seq A 0) _f p0) a0))
             with
             | 1 =>
                 K S
                   (fun (n0 : nat) (a1 : A n0) =>
                    a1 ^+) (nat_add_zero_r k)
             end
         |};
       diag_equiv_isequiv :=
         fun i : Graph.graph0 sequence_graph =>
         equiv_isequiv
           (equiv_path (A (i + 0)) (A i)
              (ap A (nat_add_zero_r i)))
     |} (iscolimit_colimit (shift_seq A 0))
     (iscolimit_colimit A)) (glue (shift_seq A 0) n a)
    +
H: Funext
A: Sequence
forall n : Graph.graph0 sequence_graph,
colim_shift_seq_to_colim_seq A 0
o inj (shift_seq A 0) n ==
equiv_functor_colimit
  {|
    diag_equiv_map :=
      {|
        DiagramMap_obj :=
          fun k : Graph.graph0 sequence_graph =>
          coe (ap A (nat_add_zero_r k));
        DiagramMap_comm :=
          fun (k l : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph k l)
            (a : shift_seq A 0 k) =>
          match
            p as p0 in (_ = n0)
            return
              ((A _f p0)
                 (equiv_path (A (k + 0)) (A k)
                    (ap A (nat_add_zero_r k)) a) =
               equiv_path (A (n0 + 0)) (A n0)
                 (ap A (nat_add_zero_r n0))
                 (((shift_seq A 0) _f p0) a))
          with
          | 1 =>
              K S
                (fun (n0 : nat) (a0 : A n0) => a0 ^+)
                (nat_add_zero_r k)
          end
      |};
    diag_equiv_isequiv :=
      fun i : Graph.graph0 sequence_graph =>
      equiv_isequiv
        (equiv_path (A (i + 0)) (A i)
           (ap A (nat_add_zero_r i)))
  |} (iscolimit_colimit (shift_seq A 0))
  (iscolimit_colimit A) o inj (shift_seq A 0) n intros k a; exact (J (nat_add_zero_r k)).
    +
H: Funext
A: Sequence
forall (n : Graph.graph0 sequence_graph)
(a : shift_seq A 0 n),
ap (colim_shift_seq_to_colim_seq A 0)
  (glue (shift_seq A 0) n a) @
(fun k : Graph.graph0 sequence_graph =>
 (fun a0 : shift_seq A 0 k => J (nat_add_zero_r k))
 :
 colim_shift_seq_to_colim_seq A 0
 o inj (shift_seq A 0) k ==
 equiv_functor_colimit
   {|
     diag_equiv_map :=
       {|
         DiagramMap_obj :=
           fun k0 : Graph.graph0 sequence_graph =>
           coe (ap A (nat_add_zero_r k0));
         DiagramMap_comm :=
           fun (k0 l : Graph.graph0 sequence_graph)
             (p : Graph.graph1 sequence_graph k0 l)
             (a0 : shift_seq A 0 k0) =>
           match
             p as p0 in (_ = n0)
             return
               ((A _f p0)
                  (equiv_path (...) (...) (...) a0) =
                equiv_path (A (...)) (A n0)
                  (ap A (...)) ((...) a0))
           with
           | 1 =>
               K S
                 (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                 (nat_add_zero_r k0)
           end
       |};
     diag_equiv_isequiv :=
       fun i : Graph.graph0 sequence_graph =>
       equiv_isequiv
         (equiv_path (A (i + 0)) (A i)
            (ap A (nat_add_zero_r i)))
   |} (iscolimit_colimit (shift_seq A 0))
   (iscolimit_colimit A) o inj (shift_seq A 0) k) n a =
(fun k : Graph.graph0 sequence_graph =>
 (fun a0 : shift_seq A 0 k => J (nat_add_zero_r k))
 :
 colim_shift_seq_to_colim_seq A 0
 o inj (shift_seq A 0) k ==
 equiv_functor_colimit
   {|
     diag_equiv_map :=
       {|
         DiagramMap_obj :=
           fun k0 : Graph.graph0 sequence_graph =>
           coe (ap A (nat_add_zero_r k0));
         DiagramMap_comm :=
           fun (k0 l : Graph.graph0 sequence_graph)
             (p : Graph.graph1 sequence_graph k0 l)
             (a0 : shift_seq A 0 k0) =>
           match
             p as p0 in (_ = n0)
             return
               ((A _f p0)
                  (equiv_path (...) (...) (...) a0) =
                equiv_path (A (...)) (A n0)
                  (ap A (...)) ((...) a0))
           with
           | 1 =>
               K S
                 (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                 (nat_add_zero_r k0)
           end
       |};
     diag_equiv_isequiv :=
       fun i : Graph.graph0 sequence_graph =>
       equiv_isequiv
         (equiv_path (A (i + 0)) (A i)
            (ap A (nat_add_zero_r i)))
   |} (iscolimit_colimit (shift_seq A 0))
   (iscolimit_colimit A) o inj (shift_seq A 0) k) n.+1
  a ^+ @
ap
  (equiv_functor_colimit
     {|
       diag_equiv_map :=
         {|
           DiagramMap_obj :=
             fun k : Graph.graph0 sequence_graph =>
             coe (ap A (nat_add_zero_r k));
           DiagramMap_comm :=
             fun (k l : Graph.graph0 sequence_graph)
               (p : Graph.graph1 sequence_graph k l)
               (a0 : shift_seq A 0 k) =>
             match
               p as p0 in (_ = n0)
               return
                 ((A _f p0)
                    (equiv_path (A (k + 0)) (A k)
                       (ap A (nat_add_zero_r k)) a0) =
                  equiv_path (A (n0 + 0)) (A n0)
                    (ap A (nat_add_zero_r n0))
                    (((shift_seq A 0) _f p0) a0))
             with
             | 1 =>
                 K S
                   (fun (n0 : nat) (a1 : A n0) =>
                    a1 ^+) (nat_add_zero_r k)
             end
         |};
       diag_equiv_isequiv :=
         fun i : Graph.graph0 sequence_graph =>
         equiv_isequiv
           (equiv_path (A (i + 0)) (A i)
              (ap A (nat_add_zero_r i)))
     |} (iscolimit_colimit (shift_seq A 0))
     (iscolimit_colimit A)) (glue (shift_seq A 0) n a) intros k a; rewrite !Colimit_rec_beta_colimp; exact (L (glue A)).
  -
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (shift_seq A n.+1) <~> Colimit A transitivity (Colimit (succ_seq (shift_seq A n))).
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (shift_seq A n.+1) <~>
Colimit (succ_seq (shift_seq A n))
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (succ_seq (shift_seq A n)) <~> Colimit A
    +
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (shift_seq A n.+1) <~>
Colimit (succ_seq (shift_seq A n)) srapply equiv_functor_colimit; srapply Build_diagram_equiv.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
DiagramMap (shift_seq A n.+1)
  (succ_seq (shift_seq A n))
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall i : Graph.graph0 sequence_graph, IsEquiv (?m i)
      *
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
DiagramMap (shift_seq A n.+1)
  (succ_seq (shift_seq A n)) srapply Build_DiagramMap.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall i : Graph.graph0 sequence_graph,
shift_seq A n.+1 i -> succ_seq (shift_seq A n) i
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : shift_seq A n.+1 i),
((succ_seq (shift_seq A n)) _f g)
  (?DiagramMap_obj i x) =
?DiagramMap_obj j (((shift_seq A n.+1) _f g) x)
        {
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall i : Graph.graph0 sequence_graph,
shift_seq A n.+1 i -> succ_seq (shift_seq A n) i exact (fun k => coe (ap A (nat_add_succ_r k n))). }
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : shift_seq A n.+1 i),
((succ_seq (shift_seq A n)) _f g)
  ((fun k : Graph.graph0 sequence_graph =>
    coe (ap A (nat_add_succ_r k n))) i x) =
(fun k : Graph.graph0 sequence_graph =>
 coe (ap A (nat_add_succ_r k n))) j
  (((shift_seq A n.+1) _f g) x)
        {
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : shift_seq A n.+1 i),
((succ_seq (shift_seq A n)) _f g)
  ((fun k : Graph.graph0 sequence_graph =>
    coe (ap A (nat_add_succ_r k n))) i x) =
(fun k : Graph.graph0 sequence_graph =>
 coe (ap A (nat_add_succ_r k n))) j
  (((shift_seq A n.+1) _f g) x) intros k l p a; destruct p; rapply (K S (fun n a => a^+) (nat_add_succ_r k n)). }
      *
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall i : Graph.graph0 sequence_graph,
IsEquiv
  ({|
     DiagramMap_obj :=
       fun k : Graph.graph0 sequence_graph =>
       coe (ap A (nat_add_succ_r k n));
     DiagramMap_comm :=
       fun (k l : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph k l)
         (a : shift_seq A n.+1 k) =>
       match
         p as p0 in (_ = n0)
         return
           (((succ_seq (shift_seq A n)) _f p0)
              (equiv_path (A (k + n.+1))
                 (A (k + n).+1)
                 (ap A (nat_add_succ_r k n)) a) =
            equiv_path (A (n0 + n.+1)) (A (n0 + n).+1)
              (ap A (nat_add_succ_r n0 n))
              (((shift_seq A n.+1) _f p0) a))
       with
       | 1 =>
           K S (fun (n : nat) (a0 : A n) => a0 ^+)
             (nat_add_succ_r k n)
       end
   |} i) exact _.
    +
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
Colimit (succ_seq (shift_seq A n)) <~> Colimit A srefine (transitivity (equiv_colim_succ_seq_to_colim_seq _) (Build_Equiv _ _ _ e)).
  -
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
(fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
 equiv_compose g f) (Colimit (shift_seq A n.+1))
  (Colimit (succ_seq (shift_seq A n))) (Colimit A)
  (equiv_functor_colimit
     {|
       diag_equiv_map :=
         {|
           DiagramMap_obj :=
             fun k : Graph.graph0 sequence_graph =>
             coe (ap A (nat_add_succ_r k n));
           DiagramMap_comm :=
             fun (k l : Graph.graph0 sequence_graph)
               (p : Graph.graph1 sequence_graph k l)
               (a : shift_seq A n.+1 k) =>
             match
               p as p0 in (_ = n0)
               return
                 (((succ_seq (shift_seq A n)) _f p0)
                    (equiv_path (A (k + n.+1))
                       (A (k + n).+1)
                       (ap A (nat_add_succ_r k n)) a) =
                  equiv_path (A (n0 + n.+1))
                    (A (n0 + n).+1)
                    (ap A (nat_add_succ_r n0 n))
                    (((shift_seq A n.+1) _f p0) a))
             with
             | 1 =>
                 K S
                   (fun (n : nat) (a0 : A n) => a0 ^+)
                   (nat_add_succ_r k n)
             end
         |};
       diag_equiv_isequiv :=
         fun i : Graph.graph0 sequence_graph =>
         equiv_isequiv
           (equiv_path (A (i + n.+1)) (A (i + n).+1)
              (ap A (nat_add_succ_r i n)))
     |} (iscolimit_colimit (shift_seq A n.+1))
     (iscolimit_colimit (succ_seq (shift_seq A n))))
  (transitivity
     (equiv_colim_succ_seq_to_colim_seq
        (shift_seq A n))
     {|
       equiv_fun := colim_shift_seq_to_colim_seq A n;
       equiv_isequiv := e
     |}) == colim_shift_seq_to_colim_seq A n.+1 symmetry; srapply seq_colimit_uniq.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall n0 : Graph.graph0 sequence_graph,
colim_shift_seq_to_colim_seq A n.+1
o inj (shift_seq A n.+1) n0 ==
(fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
 equiv_compose g f) (Colimit (shift_seq A n.+1))
  (Colimit (succ_seq (shift_seq A n))) (Colimit A)
  (equiv_functor_colimit
     {|
       diag_equiv_map :=
         {|
           DiagramMap_obj :=
             fun k : Graph.graph0 sequence_graph =>
             coe (ap A (nat_add_succ_r k n));
           DiagramMap_comm :=
             fun (k l : Graph.graph0 sequence_graph)
               (p : Graph.graph1 sequence_graph k l)
               (a : shift_seq A n.+1 k) =>
             match
               p as p0 in (_ = n1)
               return
                 (((succ_seq (shift_seq A n)) _f p0)
                    (equiv_path (A (k + n.+1))
                       (A (k + n).+1)
                       (ap A (nat_add_succ_r k n)) a) =
                  equiv_path (A (n1 + n.+1))
                    (A (n1 + n).+1)
                    (ap A (nat_add_succ_r n1 n))
                    (((shift_seq A n.+1) _f p0) a))
             with
             | 1 =>
                 K S
                   (fun (n : nat) (a0 : A n) => a0 ^+)
                   (nat_add_succ_r k n)
             end
         |};
       diag_equiv_isequiv :=
         fun i : Graph.graph0 sequence_graph =>
         equiv_isequiv
           (equiv_path (A (i + n.+1)) (A (i + n).+1)
              (ap A (nat_add_succ_r i n)))
     |} (iscolimit_colimit (shift_seq A n.+1))
     (iscolimit_colimit (succ_seq (shift_seq A n))))
  (transitivity
     (equiv_colim_succ_seq_to_colim_seq
        (shift_seq A n))
     {|
       equiv_fun := colim_shift_seq_to_colim_seq A n;
       equiv_isequiv := e
     |}) o inj (shift_seq A n.+1) n0
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall (n0 : Graph.graph0 sequence_graph)
(a : shift_seq A n.+1 n0),
ap (colim_shift_seq_to_colim_seq A n.+1)
  (glue (shift_seq A n.+1) n0 a) @ ?h n0 a =
?h n0.+1 a ^+ @
ap
  ((fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
    equiv_compose g f) (Colimit (shift_seq A n.+1))
     (Colimit (succ_seq (shift_seq A n))) (Colimit A)
     (equiv_functor_colimit
        {|
          diag_equiv_map :=
            {|
              DiagramMap_obj :=
                fun k : Graph.graph0 sequence_graph =>
                coe (ap A (nat_add_succ_r k n));
              DiagramMap_comm :=
                fun
                  (k l : Graph.graph0 sequence_graph)
                  (p : Graph.graph1 sequence_graph k l)
                  (a0 : shift_seq A n.+1 k) =>
                match
                  p as p0 in (_ = n1)
                  return
                    (((succ_seq (...)) _f p0)
                       (equiv_path (A (...))
                          (A (...).+1) (ap A (...)) a0) =
                     equiv_path (A (n1 + n.+1))
                       (A (n1 + n).+1)
                       (ap A (nat_add_succ_r n1 n))
                       (((...) _f p0) a0))
                with
                | 1 =>
                    K S
                      (fun (n : nat) (a1 : A n) =>
                       a1 ^+) (nat_add_succ_r k n)
                end
            |};
          diag_equiv_isequiv :=
            fun i : Graph.graph0 sequence_graph =>
            equiv_isequiv
              (equiv_path (A (i + n.+1))
                 (A (i + n).+1)
                 (ap A (nat_add_succ_r i n)))
        |} (iscolimit_colimit (shift_seq A n.+1))
        (iscolimit_colimit (succ_seq (shift_seq A n))))
     (transitivity
        (equiv_colim_succ_seq_to_colim_seq
           (shift_seq A n))
        {|
          equiv_fun :=
            colim_shift_seq_to_colim_seq A n;
          equiv_isequiv := e
        |})) (glue (shift_seq A n.+1) n0 a)
    +
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall n0 : Graph.graph0 sequence_graph,
colim_shift_seq_to_colim_seq A n.+1
o inj (shift_seq A n.+1) n0 ==
(fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
 equiv_compose g f) (Colimit (shift_seq A n.+1))
  (Colimit (succ_seq (shift_seq A n))) (Colimit A)
  (equiv_functor_colimit
     {|
       diag_equiv_map :=
         {|
           DiagramMap_obj :=
             fun k : Graph.graph0 sequence_graph =>
             coe (ap A (nat_add_succ_r k n));
           DiagramMap_comm :=
             fun (k l : Graph.graph0 sequence_graph)
               (p : Graph.graph1 sequence_graph k l)
               (a : shift_seq A n.+1 k) =>
             match
               p as p0 in (_ = n1)
               return
                 (((succ_seq (shift_seq A n)) _f p0)
                    (equiv_path (A (k + n.+1))
                       (A (k + n).+1)
                       (ap A (nat_add_succ_r k n)) a) =
                  equiv_path (A (n1 + n.+1))
                    (A (n1 + n).+1)
                    (ap A (nat_add_succ_r n1 n))
                    (((shift_seq A n.+1) _f p0) a))
             with
             | 1 =>
                 K S
                   (fun (n : nat) (a0 : A n) => a0 ^+)
                   (nat_add_succ_r k n)
             end
         |};
       diag_equiv_isequiv :=
         fun i : Graph.graph0 sequence_graph =>
         equiv_isequiv
           (equiv_path (A (i + n.+1)) (A (i + n).+1)
              (ap A (nat_add_succ_r i n)))
     |} (iscolimit_colimit (shift_seq A n.+1))
     (iscolimit_colimit (succ_seq (shift_seq A n))))
  (transitivity
     (equiv_colim_succ_seq_to_colim_seq
        (shift_seq A n))
     {|
       equiv_fun := colim_shift_seq_to_colim_seq A n;
       equiv_isequiv := e
     |}) o inj (shift_seq A n.+1) n0 intros k a; exact (J (nat_add_succ_r k n)).
    +
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
forall (n0 : Graph.graph0 sequence_graph)
(a : shift_seq A n.+1 n0),
ap (colim_shift_seq_to_colim_seq A n.+1)
  (glue (shift_seq A n.+1) n0 a) @
(fun k : Graph.graph0 sequence_graph =>
 (fun a0 : shift_seq A n.+1 k =>
  J (nat_add_succ_r k n))
 :
 colim_shift_seq_to_colim_seq A n.+1
 o inj (shift_seq A n.+1) k ==
 (fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
  equiv_compose g f) (Colimit (shift_seq A n.+1))
   (Colimit (succ_seq (shift_seq A n))) (Colimit A)
   (equiv_functor_colimit
      {|
        diag_equiv_map :=
          {|
            DiagramMap_obj :=
              fun k0 : Graph.graph0 sequence_graph =>
              coe (ap A (nat_add_succ_r k0 n));
            DiagramMap_comm :=
              fun (k0 l : Graph.graph0 sequence_graph)
                (p : Graph.graph1 sequence_graph k0 l)
                (a0 : shift_seq A n.+1 k0) =>
              match
                p as p0 in (_ = n1)
                return
                  ((...) (...) =
                   equiv_path (...) (...) (...) (...))
              with
              | 1 =>
                  K S
                    (fun (n : nat) (a1 : A n) => a1 ^+)
                    (nat_add_succ_r k0 n)
              end
          |};
        diag_equiv_isequiv :=
          fun i : Graph.graph0 sequence_graph =>
          equiv_isequiv
            (equiv_path (A (i + n.+1)) (A (i + n).+1)
               (ap A (nat_add_succ_r i n)))
      |} (iscolimit_colimit (shift_seq A n.+1))
      (iscolimit_colimit (succ_seq (shift_seq A n))))
   (transitivity
      (equiv_colim_succ_seq_to_colim_seq
         (shift_seq A n))
      {|
        equiv_fun := colim_shift_seq_to_colim_seq A n;
        equiv_isequiv := e
      |}) o inj (shift_seq A n.+1) k) n0 a =
(fun k : Graph.graph0 sequence_graph =>
 (fun a0 : shift_seq A n.+1 k =>
  J (nat_add_succ_r k n))
 :
 colim_shift_seq_to_colim_seq A n.+1
 o inj (shift_seq A n.+1) k ==
 (fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
  equiv_compose g f) (Colimit (shift_seq A n.+1))
   (Colimit (succ_seq (shift_seq A n))) (Colimit A)
   (equiv_functor_colimit
      {|
        diag_equiv_map :=
          {|
            DiagramMap_obj :=
              fun k0 : Graph.graph0 sequence_graph =>
              coe (ap A (nat_add_succ_r k0 n));
            DiagramMap_comm :=
              fun (k0 l : Graph.graph0 sequence_graph)
                (p : Graph.graph1 sequence_graph k0 l)
                (a0 : shift_seq A n.+1 k0) =>
              match
                p as p0 in (_ = n1)
                return
                  ((...) (...) =
                   equiv_path (...) (...) (...) (...))
              with
              | 1 =>
                  K S
                    (fun (n : nat) (a1 : A n) => a1 ^+)
                    (nat_add_succ_r k0 n)
              end
          |};
        diag_equiv_isequiv :=
          fun i : Graph.graph0 sequence_graph =>
          equiv_isequiv
            (equiv_path (A (i + n.+1)) (A (i + n).+1)
               (ap A (nat_add_succ_r i n)))
      |} (iscolimit_colimit (shift_seq A n.+1))
      (iscolimit_colimit (succ_seq (shift_seq A n))))
   (transitivity
      (equiv_colim_succ_seq_to_colim_seq
         (shift_seq A n))
      {|
        equiv_fun := colim_shift_seq_to_colim_seq A n;
        equiv_isequiv := e
      |}) o inj (shift_seq A n.+1) k) n0.+1 a ^+ @
ap
  ((fun (x y z : Type) (f : x <~> y) (g : y <~> z) =>
    equiv_compose g f) (Colimit (shift_seq A n.+1))
     (Colimit (succ_seq (shift_seq A n))) (Colimit A)
     (equiv_functor_colimit
        {|
          diag_equiv_map :=
            {|
              DiagramMap_obj :=
                fun k : Graph.graph0 sequence_graph =>
                coe (ap A (nat_add_succ_r k n));
              DiagramMap_comm :=
                fun
                  (k l : Graph.graph0 sequence_graph)
                  (p : Graph.graph1 sequence_graph k l)
                  (a0 : shift_seq A n.+1 k) =>
                match
                  p as p0 in (_ = n1)
                  return
                    (((succ_seq (...)) _f p0)
                       (equiv_path (A (...))
                          (A (...).+1) (ap A (...)) a0) =
                     equiv_path (A (n1 + n.+1))
                       (A (n1 + n).+1)
                       (ap A (nat_add_succ_r n1 n))
                       (((...) _f p0) a0))
                with
                | 1 =>
                    K S
                      (fun (n : nat) (a1 : A n) =>
                       a1 ^+) (nat_add_succ_r k n)
                end
            |};
          diag_equiv_isequiv :=
            fun i : Graph.graph0 sequence_graph =>
            equiv_isequiv
              (equiv_path (A (i + n.+1))
                 (A (i + n).+1)
                 (ap A (nat_add_succ_r i n)))
        |} (iscolimit_colimit (shift_seq A n.+1))
        (iscolimit_colimit (succ_seq (shift_seq A n))))
     (transitivity
        (equiv_colim_succ_seq_to_colim_seq
           (shift_seq A n))
        {|
          equiv_fun :=
            colim_shift_seq_to_colim_seq A n;
          equiv_isequiv := e
        |})) (glue (shift_seq A n.+1) n0 a) intros k a; rewrite Colimit_rec_beta_colimp; simpl.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
k: Graph.graph0 sequence_graph
a: shift_seq A n.+1 k
colimp (k + n.+1) (k + n.+1).+1 1 a @
J (nat_add_succ_r k n) =
J (ap S (nat_add_succ_r k n)) @
ap
  (fun x : Colimit (shift_seq A n.+1) =>
   colim_shift_seq_to_colim_seq A n
     (colim_succ_seq_to_colim_seq (shift_seq A n)
        (functor_colimit
           {|
             DiagramMap_obj :=
               fun k : nat =>
               transport idmap
                 (ap A (nat_add_succ_r k n));
             DiagramMap_comm :=
               fun (k l : nat) (p : k.+1 = l)
                 (a : A (k + n.+1)) =>
               match
                 p as p0 in (_ = n0)
                 return
                   (match
                      p0 in (_ = n1)
                      return (... -> ...)
                    with
                    | 1 => fun a0 : A ....+1 => a0 ^+
                    end
                      (transport idmap
                         (ap A (nat_add_succ_r k n)) a) =
                    transport idmap
                      (ap A (nat_add_succ_r n0 n))
                      (match p0 in ... return ... with
                       | 1 => fun ... => a0 ^+
                       end a))
               with
               | 1 =>
                   K S
                     (fun (n : nat) (a0 : A n) =>
                      a0 ^+) (nat_add_succ_r k n)
               end
           |} (iscolimit_colimit (shift_seq A n.+1))
           (iscolimit_colimit
              (succ_seq (shift_seq A n))) x)))
  (colimp k k.+1 1 a)
      rewrite 2(ap_compose' _ _ (glue _ k a)), Colimit_rec_beta_colimp, 2ap_pp.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
k: Graph.graph0 sequence_graph
a: shift_seq A n.+1 k
colimp (k + n.+1) (k + n.+1).+1 1 a @
J (nat_add_succ_r k n) =
J (ap S (nat_add_succ_r k n)) @
(ap (colim_shift_seq_to_colim_seq A n)
   (ap (colim_succ_seq_to_colim_seq (shift_seq A n))
      (ap
         (iscolimit_colimit (succ_seq (shift_seq A n))
            k.+1)
         (DiagramMap_comm
            {|
              DiagramMap_obj :=
                fun k : nat =>
                transport idmap
                  (ap A (nat_add_succ_r k n));
              DiagramMap_comm :=
                fun (k l : nat) (p : k.+1 = l)
                  (a : A (k + n.+1)) =>
                match
                  p as p0 in (_ = n0)
                  return
                    (match
                       p0 in (...) return (...)
                     with
                     | 1 => fun a0 : ... => a0 ^+
                     end
                       (transport idmap (ap A (...)) a) =
                     transport idmap
                       (ap A (nat_add_succ_r n0 n))
                       (match ... ... with
                        | ... => ... => ...
                        end a))
                with
                | 1 =>
                    K S
                      (fun (n : nat) (a0 : A n) =>
                       a0 ^+) (nat_add_succ_r k n)
                end
            |} 1 a)^)) @
 ap (colim_shift_seq_to_colim_seq A n)
   (ap (colim_succ_seq_to_colim_seq (shift_seq A n))
      (legs_comm
         (iscolimit_colimit (succ_seq (shift_seq A n)))
         k k.+1 1
         ({|
            DiagramMap_obj :=
              fun k : nat =>
              transport idmap
                (ap A (nat_add_succ_r k n));
            DiagramMap_comm :=
              fun (k l : nat) (p : k.+1 = l)
                (a : A (k + n.+1)) =>
              match
                p as p0 in (_ = n0)
                return
                  (match p0 in (...) return (...) with
                   | 1 => fun a0 : ... => a0 ^+
                   end
                     (transport idmap (ap A (...)) a) =
                   transport idmap
                     (ap A (nat_add_succ_r n0 n))
                     (match ... ... with
                      | ... => ... => ...
                      end a))
              with
              | 1 =>
                  K S
                    (fun (n : nat) (a0 : A n) => a0 ^+)
                    (nat_add_succ_r k n)
              end
          |} k a))))
      rewrite colim_succ_seq_to_colim_seq_ap_inj, colim_shift_seq_to_colim_seq_ap_inj.
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
k: Graph.graph0 sequence_graph
a: shift_seq A n.+1 k
colimp (k + n.+1) (k + n.+1).+1 1 a @
J (nat_add_succ_r k n) =
J (ap S (nat_add_succ_r k n)) @
(ap (inj A (k.+2 + n))
   (DiagramMap_comm
      {|
        DiagramMap_obj :=
          fun k : nat =>
          transport idmap (ap A (nat_add_succ_r k n));
        DiagramMap_comm :=
          fun (k l : nat) (p : k.+1 = l)
            (a : A (k + n.+1)) =>
          match
            p as p0 in (_ = n0)
            return
              (match
                 p0 in (_ = n1)
                 return
                   (A (k + n).+1 -> A (n1 + n).+1)
               with
               | 1 => fun a0 : A (k + n).+1 => a0 ^+
               end
                 (transport idmap
                    (ap A (nat_add_succ_r k n)) a) =
               transport idmap
                 (ap A (nat_add_succ_r n0 n))
                 (match
                    p0 in (_ = n1)
                    return (A ... -> A ...)
                  with
                  | 1 => fun a0 : A (...) => a0 ^+
                  end a))
          with
          | 1 =>
              K S (fun (n : nat) (a0 : A n) => a0 ^+)
                (nat_add_succ_r k n)
          end
      |} 1 a)^ @
 ap (colim_shift_seq_to_colim_seq A n)
   (ap (colim_succ_seq_to_colim_seq (shift_seq A n))
      (legs_comm
         (iscolimit_colimit (succ_seq (shift_seq A n)))
         k k.+1 1
         ({|
            DiagramMap_obj :=
              fun k : nat =>
              transport idmap
                (ap A (nat_add_succ_r k n));
            DiagramMap_comm :=
              fun (k l : nat) (p : k.+1 = l)
                (a : A (k + n.+1)) =>
              match
                p as p0 in (_ = n0)
                return
                  (match p0 in (...) return (...) with
                   | 1 => fun a0 : ... => a0 ^+
                   end
                     (transport idmap (ap A (...)) a) =
                   transport idmap
                     (ap A (nat_add_succ_r n0 n))
                     (match ... ... with
                      | ... => ... => ...
                      end a))
              with
              | 1 =>
                  K S
                    (fun (n : nat) (a0 : A n) => a0 ^+)
                    (nat_add_succ_r k n)
              end
          |} k a))))
      rewrite (colim_succ_seq_to_colim_seq_beta_glue (shift_seq A n)).
H: Funext
A: Sequence
n: nat
e: IsEquiv (colim_shift_seq_to_colim_seq A n)
k: Graph.graph0 sequence_graph
a: shift_seq A n.+1 k
colimp (k + n.+1) (k + n.+1).+1 1 a @
J (nat_add_succ_r k n) =
J (ap S (nat_add_succ_r k n)) @
(ap (inj A (k.+2 + n))
   (DiagramMap_comm
      {|
        DiagramMap_obj :=
          fun k : nat =>
          transport idmap (ap A (nat_add_succ_r k n));
        DiagramMap_comm :=
          fun (k l : nat) (p : k.+1 = l)
            (a : A (k + n.+1)) =>
          match
            p as p0 in (_ = n0)
            return
              (match
                 p0 in (_ = n1)
                 return
                   (A (k + n).+1 -> A (n1 + n).+1)
               with
               | 1 => fun a0 : A (k + n).+1 => a0 ^+
               end
                 (transport idmap
                    (ap A (nat_add_succ_r k n)) a) =
               transport idmap
                 (ap A (nat_add_succ_r n0 n))
                 (match
                    p0 in (_ = n1)
                    return (A ... -> A ...)
                  with
                  | 1 => fun a0 : A (...) => a0 ^+
                  end a))
          with
          | 1 =>
              K S (fun (n : nat) (a0 : A n) => a0 ^+)
                (nat_add_succ_r k n)
          end
      |} 1 a)^ @
 ap (colim_shift_seq_to_colim_seq A n)
   (colimp k.+1 k.+2 1
      ({|
         DiagramMap_obj :=
           fun k : nat =>
           transport idmap (ap A (nat_add_succ_r k n));
         DiagramMap_comm :=
           fun (k l : nat) (p : k.+1 = l)
             (a : A (k + n.+1)) =>
           match
             p as p0 in (_ = n0)
             return
               (match
                  p0 in (_ = n1)
                  return (A ....+1 -> A ....+1)
                with
                | 1 => fun a0 : A (...).+1 => a0 ^+
                end
                  (transport idmap
                     (ap A (nat_add_succ_r k n)) a) =
                transport idmap
                  (ap A (nat_add_succ_r n0 n))
                  (match p0 in (...) return (...) with
                   | 1 => fun a0 : ... => a0 ^+
                   end a))
           with
           | 1 =>
               K S (fun (n : nat) (a0 : A n) => a0 ^+)
                 (nat_add_succ_r k n)
           end
       |} k a)))
      rewrite colim_shift_seq_to_colim_seq_beta_glue; exact (L (glue A)).
Defined.

Definition equiv_colim_shift_seq_to_colim_seq `{Funext} A n
  : Colimit (shift_seq A n) <~> Colimit A
  := Build_Equiv _ _ (colim_shift_seq_to_colim_seq A n) _.

(** Corollary 7.7.1 for k := -2; implies Lemma 7.2. *)
Definition contr_colim_contr_seq `{Funext} (A : Sequence)
  : (forall k, Contr (A k)) -> Contr (Colimit A).
H: Funext
A: Sequence
(forall k : Graph.graph0 sequence_graph, Contr (A k)) ->
Contr (Colimit A)
Proof.
H: Funext
A: Sequence
(forall k : Graph.graph0 sequence_graph, Contr (A k)) ->
Contr (Colimit A)
  intro h_seqcontr; pose (unit_seq := Build_Sequence (fun _ => Unit) (fun _ _ => tt)).
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
Contr (Colimit A)
  srapply (contr_equiv' (Colimit unit_seq)).
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
Colimit unit_seq <~> Colimit A
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
Contr (Colimit unit_seq)
  -
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
Colimit unit_seq <~> Colimit A symmetry; srapply equiv_functor_colimit.
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
A ~d~ unit_seq
    srapply Build_diagram_equiv; srapply Build_DiagramMap.
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall i : Graph.graph0 sequence_graph,
A i -> unit_seq i
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) 
(x : A i),
(unit_seq _f g) (?DiagramMap_obj i x) =
?DiagramMap_obj j ((A _f g) x)
    *
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall i : Graph.graph0 sequence_graph,
A i -> unit_seq i exact (fun _ _ => tt).
    *
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
(unit_seq _f g)
  ((fun (i0 : Graph.graph0 sequence_graph) (_ : A i0)
    => tt) i x) =
(fun (i0 : Graph.graph0 sequence_graph) (_ : A i0) =>
 tt) j ((A _f g) x) intros n m p a; destruct p; reflexivity.
  -
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
Contr (Colimit unit_seq) srapply (Build_Contr _ (inj unit_seq 0 tt)); intro y; symmetry; revert y.
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall y : Colimit unit_seq, y = inj unit_seq 0 tt
    srapply seq_colimit_uniq.
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall n : Graph.graph0 sequence_graph,
idmap o inj unit_seq n ==
(fun _ : Colimit unit_seq => inj unit_seq 0 tt)
o inj unit_seq n
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall (n : Graph.graph0 sequence_graph)
(a : unit_seq n),
ap idmap (glue unit_seq n a) @ ?h n a =
?h n.+1 a ^+ @
ap (fun _ : Colimit unit_seq => inj unit_seq 0 tt)
  (glue unit_seq n a)
    *
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall n : Graph.graph0 sequence_graph,
idmap o inj unit_seq n ==
(fun _ : Colimit unit_seq => inj unit_seq 0 tt)
o inj unit_seq n intros n a; destruct a; induction n as [ | n r].
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
inj unit_seq 0 tt = inj unit_seq 0 tt
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
n: nat
r: inj unit_seq n tt = inj unit_seq 0 tt
inj unit_seq n.+1 tt = inj unit_seq 0 tt
      +
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
inj unit_seq 0 tt = inj unit_seq 0 tt reflexivity.
      +
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
n: nat
r: inj unit_seq n tt = inj unit_seq 0 tt
inj unit_seq n.+1 tt = inj unit_seq 0 tt exact (glue unit_seq n tt @ r).
    *
H: Funext
A: Sequence
h_seqcontr: forall k : Graph.graph0 sequence_graph,
Contr (A k)
unit_seq:= Build_Sequence (fun _ : nat => Unit)
  (fun (n : nat)
     (_ : (fun _ : nat => Unit) n) => tt): Sequence
forall (n : Graph.graph0 sequence_graph)
(a : unit_seq n),
ap idmap (glue unit_seq n a) @
(fun n0 : Graph.graph0 sequence_graph =>
 (fun a0 : unit_seq n0 =>
  match
    a0 as u
    return (inj unit_seq n0 u = inj unit_seq 0 tt)
  with
  | tt =>
      nat_rect
        (fun n1 : nat =>
         inj unit_seq n1 tt = inj unit_seq 0 tt) 1
        (fun (n1 : nat)
           (r : inj unit_seq n1 tt = inj unit_seq 0 tt)
         => glue unit_seq n1 tt @ r) n0
  end)
 :
 idmap o inj unit_seq n0 ==
 (fun _ : Colimit unit_seq => inj unit_seq 0 tt)
 o inj unit_seq n0) n a =
(fun n0 : Graph.graph0 sequence_graph =>
 (fun a0 : unit_seq n0 =>
  match
    a0 as u
    return (inj unit_seq n0 u = inj unit_seq 0 tt)
  with
  | tt =>
      nat_rect
        (fun n1 : nat =>
         inj unit_seq n1 tt = inj unit_seq 0 tt) 1
        (fun (n1 : nat)
           (r : inj unit_seq n1 tt = inj unit_seq 0 tt)
         => glue unit_seq n1 tt @ r) n0
  end)
 :
 idmap o inj unit_seq n0 ==
 (fun _ : Colimit unit_seq => inj unit_seq 0 tt)
 o inj unit_seq n0) n.+1 a ^+ @
ap (fun _ : Colimit unit_seq => inj unit_seq 0 tt)
  (glue unit_seq n a) intro n; destruct a; rewrite ap_idmap, ap_const, concat_p1; reflexivity.
Defined.

(** Fibered sequences; Section 4. *)
Record FibSequence (A : Sequence) := {
  fibSequence : sig A -> Type;
  fibSequenceArr x : fibSequence x -> fibSequence x^++
}.

Coercion fibSequence : FibSequence  >-> Funclass.

Arguments fibSequence {A}.
Arguments fibSequenceArr {A}.

Notation "b ^+f" := (fibSequenceArr _ _ b).

(** The Sigma of a fibered type sequence; Definition 4.3. *)
Definition sig_seq {A} (B : FibSequence A) : Sequence.
A: Sequence
B: FibSequence A
Sequence
Proof.
A: Sequence
B: FibSequence A
Sequence
  srapply Build_Sequence.
A: Sequence
B: FibSequence A
nat -> Type
A: Sequence
B: FibSequence A
forall n : nat, ?X n -> ?X n.+1
  -
A: Sequence
B: FibSequence A
nat -> Type exact (fun n => {a : A n & B (n;a)}).
  -
A: Sequence
B: FibSequence A
forall n : nat,
(fun n0 : nat => {a : A n0 & B (n0; a)}) n ->
(fun n0 : nat => {a : A n0 & B (n0; a)}) n.+1 intros n [a b]; exact (a^+; b^+f).
Defined.

(** The canonical projection from the sequential colimit of Sigmas to the sequential colimit of the first component; Definition 4.3. *)
Definition seq_colim_sum_to_seq_colim_fst {A} (B : FibSequence A)
  : Colimit (sig_seq B) -> Colimit A.
A: Sequence
B: FibSequence A
Colimit (sig_seq B) -> Colimit A
Proof.
A: Sequence
B: FibSequence A
Colimit (sig_seq B) -> Colimit A
  srapply Colimit_rec; srapply Build_Cocone.
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph,
sig_seq B i -> Colimit A
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o (sig_seq B) _f g == ?legs i
  -
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph,
sig_seq B i -> Colimit A intros n [a _]; exact (inj _ n a).
  -
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (n : Graph.graph0 sequence_graph)
   (X : sig_seq B n) =>
 (fun (a : A n) (_ : B (n; a)) => inj A n a) X.1 X.2)
  j o (sig_seq B) _f g ==
(fun (n : Graph.graph0 sequence_graph)
   (X : sig_seq B n) =>
 (fun (a : A n) (_ : B (n; a)) => inj A n a) X.1 X.2)
  i intros n m p [a b]; destruct p; exact (glue _ n a).
Defined.

(** Given a sequence fibered over [A], each point [x : sig A] induces a new type sequence; Section 4. *)
Definition fib_seq_to_seq {A} (B : FibSequence A) (x : sig A) : Sequence.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
Sequence
Proof.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
Sequence
  srapply Build_Sequence; intro k; revert x; induction k as [ | k h].
A: Sequence
B: FibSequence A
{x : _ & A x} -> Type
A: Sequence
B: FibSequence A
k: nat
h: {x : _ & A x} -> Type
{x : _ & A x} -> Type
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) => ?Goal0)
  0 x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) => ?Goal0)
  1 x
A: Sequence
B: FibSequence A
k: nat
h: forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) =>
   ?Goal0) k x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) =>
   ?Goal0) k.+1 x
forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) => ?Goal0)
  k.+1 x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k : nat) (h : {x : _ & A x} -> Type) => ?Goal0)
  k.+2 x
  *
A: Sequence
B: FibSequence A
{x : _ & A x} -> Type exact (fun x => B x).
  *
A: Sequence
B: FibSequence A
k: nat
h: {x : _ & A x} -> Type
{x : _ & A x} -> Type exact (fun x => h x^++).
  *
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) 0 x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) 1 x exact (fun x b => b^+f).
  *
A: Sequence
B: FibSequence A
k: nat
h: forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) k x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) k.+1 x
forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) k.+1 x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h : {x : _ & A x} -> Type)
     (x0 : {x : _ & A x}) => h x0 ^++) k.+2 x exact (fun x => h x^++).
Defined.

(** The induced sequence can be equivalently described by using shifting; Lemma 7.1. *)
Definition fib_seq_to_seq' {A} (B : FibSequence A) (x : sig A) : Sequence
  := Build_Sequence (fun k => B x^++k) (fun k b => b^+f).

Definition equiv_fib_seq_to_seq {A} (B : FibSequence A) (x : sig A)
  : fib_seq_to_seq B x ~d~ fib_seq_to_seq' B x.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
fib_seq_to_seq B x ~d~ fib_seq_to_seq' B x
Proof.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
fib_seq_to_seq B x ~d~ fib_seq_to_seq' B x
  srapply Build_diagram_equiv.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
DiagramMap (fib_seq_to_seq B x) (fib_seq_to_seq' B x)
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall i : Graph.graph0 sequence_graph, IsEquiv (?m i)
  +
A: Sequence
B: FibSequence A
x: {x : _ & A x}
DiagramMap (fib_seq_to_seq B x) (fib_seq_to_seq' B x) srapply Build_DiagramMap.
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall i : Graph.graph0 sequence_graph,
fib_seq_to_seq B x i -> fib_seq_to_seq' B x i
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x0 : fib_seq_to_seq B x i),
((fib_seq_to_seq' B x) _f g) (?DiagramMap_obj i x0) =
?DiagramMap_obj j (((fib_seq_to_seq B x) _f g) x0)
    *
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall i : Graph.graph0 sequence_graph,
fib_seq_to_seq B x i -> fib_seq_to_seq' B x i intro n; revert x; induction n as [ | n e].
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
fib_seq_to_seq B x 0 -> fib_seq_to_seq' B x 0
A: Sequence
B: FibSequence A
n: nat
e: forall x : {x : _ & A x},
fib_seq_to_seq B x n -> fib_seq_to_seq' B x n
forall x : {x : _ & A x},
fib_seq_to_seq B x n.+1 -> fib_seq_to_seq' B x n.+1
      -
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
fib_seq_to_seq B x 0 -> fib_seq_to_seq' B x 0 exact (fun _ => idmap).
      -
A: Sequence
B: FibSequence A
n: nat
e: forall x : {x : _ & A x},
fib_seq_to_seq B x n -> fib_seq_to_seq' B x n
forall x : {x : _ & A x},
fib_seq_to_seq B x n.+1 -> fib_seq_to_seq' B x n.+1 exact (fun x => coe (ap B (seq_pair_shift_assoc x n)) o e x^++).
    *
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x0 : fib_seq_to_seq B x i),
((fib_seq_to_seq' B x) _f g)
  ((fun n : Graph.graph0 sequence_graph =>
    nat_rect
      (fun n0 : nat =>
       forall x : {x : _ & A x},
       fib_seq_to_seq B x n0 -> fib_seq_to_seq' B x n0)
      (fun x : {x : _ & A x} => idmap)
      (fun (n0 : nat)
         (e : forall x : {x : _ & A x},
              fib_seq_to_seq B x n0 ->
              fib_seq_to_seq' B x n0)
         (x : {x : _ & A x}) =>
       coe (ap B (seq_pair_shift_assoc x n0))
       o e x ^++) n x) i x0) =
(fun n : Graph.graph0 sequence_graph =>
 nat_rect
   (fun n0 : nat =>
    forall x : {x : _ & A x},
    fib_seq_to_seq B x n0 -> fib_seq_to_seq' B x n0)
   (fun x : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x : {x : _ & A x},
           fib_seq_to_seq B x n0 ->
           fib_seq_to_seq' B x n0) (x : {x : _ & A x})
    =>
    coe (ap B (seq_pair_shift_assoc x n0)) o e x ^++)
   n x) j (((fib_seq_to_seq B x) _f g) x0) intros n m p; destruct p; revert x; induction n as [ | n p].
A: Sequence
B: FibSequence A
forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x 0),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
   0 x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n) (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
  1 x x0 ^+
A: Sequence
B: FibSequence A
n: nat
p: forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x n),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n ->
    fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n)
      (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n))
      (e x1 ^++ x2)) n x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n)
     (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n))
     (e x1 ^++ x2)) n.+1 x x0 ^+
forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x n.+1),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
   n.+1 x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n) (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
  n.+2 x x0 ^+
      -
A: Sequence
B: FibSequence A
forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x 0),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
   0 x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n) (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
  1 x x0 ^+ exact (fun _ _ => idpath).
      -
A: Sequence
B: FibSequence A
n: nat
p: forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x n),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n ->
    fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n)
      (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n))
      (e x1 ^++ x2)) n x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n)
     (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n))
     (e x1 ^++ x2)) n.+1 x x0 ^+
forall (x : {x : _ & A x})
(x0 : fib_seq_to_seq B x n.+1),
(nat_rect
   (fun n : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n ->
           fib_seq_to_seq' B x1 n)
      (x1 : {x : _ & A x})
      (x2 : fib_seq_to_seq B x1 ^++ n) =>
    equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
      (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
   n.+1 x x0) ^+ =
nat_rect
  (fun n : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n -> fib_seq_to_seq' B x1 n)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n ->
          fib_seq_to_seq' B x1 n) (x1 : {x : _ & A x})
     (x2 : fib_seq_to_seq B x1 ^++ n) =>
   equiv_path (B (x1 ^++) ^++ n) (B x1 ^++ (n.+1))
     (ap B (seq_pair_shift_assoc x1 n)) (e x1 ^++ x2))
  n.+2 x x0 ^+ exact (fun x b => K _ _ _ @ (ap _ (p (x^++) b))).
  +
A: Sequence
B: FibSequence A
x: {x : _ & A x}
forall i : Graph.graph0 sequence_graph,
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x : {x : _ & A x},
          fib_seq_to_seq B x n0 ->
          fib_seq_to_seq' B x n0)
         (fun x : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x : {x : _ & A x},
                 fib_seq_to_seq B x n0 ->
                 fib_seq_to_seq' B x n0)
            (x : {x : _ & A x}) =>
          coe (ap B (seq_pair_shift_assoc x n0))
          o e x ^++) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x : {x : _ & A x},
                  fib_seq_to_seq B x n1 ->
                  fib_seq_to_seq' B x n1)
                 (fun x : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x : {x : _ & A x},
                         fib_seq_to_seq B x n1 ->
                         fib_seq_to_seq' B x n1)
                    (x : {x : _ & A x})
                    (x1 : fib_seq_to_seq B x ^++ n1)
                  =>
                  equiv_path (B (x ^++) ^++ n1)
                    (B x ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x n1))
                    (e x ^++ x1)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x : {x : _ & A x},
               fib_seq_to_seq B x n1 ->
               fib_seq_to_seq' B x n1)
              (fun x : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x : {x : _ & A x},
                      fib_seq_to_seq B x n1 ->
                      fib_seq_to_seq' B x n1)
                 (x : {x : _ & A x})
                 (x1 : fib_seq_to_seq B x ^++ n1) =>
               equiv_path (B (x ^++) ^++ n1)
                 (B x ^++ (n1.+1))
                 (ap B (seq_pair_shift_assoc x n1))
                 (e x ^++ x1)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x : {x : _ & A x})
              (x0 : fib_seq_to_seq B x n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++ n1)
                  =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n0 x x0) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x1 : {x : _ & A x},
                 fib_seq_to_seq B x1 n1 ->
                 fib_seq_to_seq' B x1 n1)
                (fun x1 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x1 : {x : _ & A x},
                        fib_seq_to_seq B x1 n1 ->
                        fib_seq_to_seq' B x1 n1)
                   (x1 : {x : _ & A x})
                   (x2 : fib_seq_to_seq B x1 ^++ n1)
                 =>
                 equiv_path (B (x1 ^++) ^++ n1)
                   (B x1 ^++ (n1.+1))
                   (ap B (seq_pair_shift_assoc x1 n1))
                   (e x1 ^++ x2)) n0.+1 x x0 ^+)
             (fun (x : {x : _ & A x})
                (x0 : fib_seq_to_seq B x 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x : {x : _ & A x})
                      (x0 : fib_seq_to_seq B x n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall x1 : {x : _ & A x},
                          fib_seq_to_seq B x1 n1 ->
                          fib_seq_to_seq' B x1 n1)
                         (fun x1 : {x : _ & A x} =>
                          idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x1 : {x : _ & ...},
                                 fib_seq_to_seq B x1
                                   n1 ->
                                 fib_seq_to_seq' B x1
                                   n1)
                            (x1 : {x : _ & A x})
                            (x2 : fib_seq_to_seq B
                                    x1 ^++ n1) =>
                          equiv_path (B (...) ^++ n1)
                            (B x1 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x1 n1))
                            (e x1 ^++ x2)) n0 x x0) ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                        (fun x1 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x1 : {x : _ & A x},
                                fib_seq_to_seq B x1 n1 ->
                                fib_seq_to_seq' B x1
                                  n1)
                           (x1 : {x : _ & A x})
                           (x2 : fib_seq_to_seq B
                                   x1 ^++ n1) =>
                         equiv_path
                           (B (x1 ^++) ^++ n1)
                           (B x1 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc x1
                                 n1)) (e x1 ^++ x2))
                        n0.+1 x x0 ^+)
                (x : {x : _ & A x})
                (b : fib_seq_to_seq B x n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x n0) @
              ap
                (equiv_path (B ((x ^++) ^++ n0) ^++)
                   (B
                      (((fix F ... : ... :=
                           ...
                           ...
                           ...
                           end) n0) ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x n0))))
                (p0 x ^++ b)) n x
       end
   |} i) intro n; revert x; induction n as [ | n e].
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++ n1)
                  =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1) =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++ n1)
                  =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++ n1)
                 =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x} =>
                          idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ & ...},
                                 fib_seq_to_seq B x2
                                   n1 ->
                                 fib_seq_to_seq' B x2
                                   n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B x2 n1 ->
                                fib_seq_to_seq' B x2
                                  n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc x2
                                 n1)) (e x2 ^++ x3))
                        n0.+1 x0 x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift x0)
                       ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0 n0))))
                (p0 x0 ^++ b)) n x
       end
   |} 0)
A: Sequence
B: FibSequence A
n: nat
e: forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall
                         x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++
                            n1) =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B
                       (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1)
               =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B
                    (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall
                         x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++
                            n1) =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B
                       (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++
                           n1) =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B
                      (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall
                          x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x}
                          => idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ &
                                      ...},
                                 fib_seq_to_seq B
                                   x2 n1 ->
                                 fib_seq_to_seq' B
                                   x2 n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path
                            (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0
                         x1) ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall
                         x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B
                                  x2 n1 ->
                                fib_seq_to_seq' B
                                  x2 n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc
                                 x2 n1))
                           (e x2 ^++ x3)) n0.+1 x0
                        x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path
                   (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift
                          x0) ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0
                            n0)))) (p0 x0 ^++ b))
             n x
       end
   |} n)
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++ n1)
                  =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1) =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++ n1)
                  =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++ n1)
                 =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x} =>
                          idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ & ...},
                                 fib_seq_to_seq B x2
                                   n1 ->
                                 fib_seq_to_seq' B x2
                                   n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B x2 n1 ->
                                fib_seq_to_seq' B x2
                                  n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc x2
                                 n1)) (e x2 ^++ x3))
                        n0.+1 x0 x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift x0)
                       ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0 n0))))
                (p0 x0 ^++ b)) n x
       end
   |} n.+1)
    *
A: Sequence
B: FibSequence A
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++ n1)
                  =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1) =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++ n1)
                  =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++ n1)
                 =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x} =>
                          idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ & ...},
                                 fib_seq_to_seq B x2
                                   n1 ->
                                 fib_seq_to_seq' B x2
                                   n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B x2 n1 ->
                                fib_seq_to_seq' B x2
                                  n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc x2
                                 n1)) (e x2 ^++ x3))
                        n0.+1 x0 x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift x0)
                       ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0 n0))))
                (p0 x0 ^++ b)) n x
       end
   |} 0) exact (fun _ => isequiv_idmap _).
    *
A: Sequence
B: FibSequence A
n: nat
e: forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall
                         x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++
                            n1) =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B
                       (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1)
               =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B
                    (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall
                         x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++
                            n1) =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B
                       (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++
                           n1) =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B
                      (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall
                          x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x}
                          => idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ &
                                      ...},
                                 fib_seq_to_seq B
                                   x2 n1 ->
                                 fib_seq_to_seq' B
                                   x2 n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path
                            (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0
                         x1) ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall
                         x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B
                                  x2 n1 ->
                                fib_seq_to_seq' B
                                  x2 n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc
                                 x2 n1))
                           (e x2 ^++ x3)) n0.+1 x0
                        x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path
                   (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift
                          x0) ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0
                            n0)))) (p0 x0 ^++ b))
             n x
       end
   |} n)
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n0 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n0 ->
          fib_seq_to_seq' B x0 n0)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n0 : nat)
            (e : forall x0 : {x : _ & A x},
                 fib_seq_to_seq B x0 n0 ->
                 fib_seq_to_seq' B x0 n0)
            (x0 : {x : _ & A x})
            (x1 : fib_seq_to_seq B x0 ^++ n0) =>
          equiv_path (B (x0 ^++) ^++ n0)
            (B x0 ^++ (n0.+1))
            (ap B (seq_pair_shift_assoc x0 n0))
            (e x0 ^++ x1)) n x;
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m) =>
       match
         p as p0 in (_ = n0)
         return
           (forall x0 : fib_seq_to_seq B x n,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n1 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n1 ->
                  fib_seq_to_seq' B x1 n1)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x1 : {x : _ & A x},
                         fib_seq_to_seq B x1 n1 ->
                         fib_seq_to_seq' B x1 n1)
                    (x1 : {x : _ & A x})
                    (x2 : fib_seq_to_seq B x1 ^++ n1)
                  =>
                  equiv_path (B (x1 ^++) ^++ n1)
                    (B x1 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x1 n1))
                    (e x1 ^++ x2)) n x x0) =
            nat_rect
              (fun n1 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n1 ->
               fib_seq_to_seq' B x1 n1)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n1 : nat)
                 (e : forall x1 : {x : _ & A x},
                      fib_seq_to_seq B x1 n1 ->
                      fib_seq_to_seq' B x1 n1)
                 (x1 : {x : _ & A x})
                 (x2 : fib_seq_to_seq B x1 ^++ n1) =>
               equiv_path (B (x1 ^++) ^++ n1)
                 (B x1 ^++ (n1.+1))
                 (ap B (seq_pair_shift_assoc x1 n1))
                 (e x1 ^++ x2)) n0 x
              (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n0 : nat =>
              forall (x0 : {x : _ & A x})
              (x1 : fib_seq_to_seq B x0 n0),
              (nat_rect
                 (fun n1 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n1 ->
                  fib_seq_to_seq' B x2 n1)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n1 : nat)
                    (e : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                    (x2 : {x : _ & A x})
                    (x3 : fib_seq_to_seq B x2 ^++ n1)
                  =>
                  equiv_path (B (x2 ^++) ^++ n1)
                    (B x2 ^++ (n1.+1))
                    (ap B (seq_pair_shift_assoc x2 n1))
                    (e x2 ^++ x3)) n0 x0 x1) ^+ =
              nat_rect
                (fun n1 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n1 ->
                 fib_seq_to_seq' B x2 n1)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n1 : nat)
                   (e : forall x2 : {x : _ & A x},
                        fib_seq_to_seq B x2 n1 ->
                        fib_seq_to_seq' B x2 n1)
                   (x2 : {x : _ & A x})
                   (x3 : fib_seq_to_seq B x2 ^++ n1)
                 =>
                 equiv_path (B (x2 ^++) ^++ n1)
                   (B x2 ^++ (n1.+1))
                   (ap B (seq_pair_shift_assoc x2 n1))
                   (e x2 ^++ x3)) n0.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x})
                (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n0 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n0),
                      (nat_rect
                         (fun n1 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n1 ->
                          fib_seq_to_seq' B x2 n1)
                         (fun x2 : {x : _ & A x} =>
                          idmap)
                         (fun (n1 : nat)
                            (e : forall
                                 x2 : {x : _ & ...},
                                 fib_seq_to_seq B x2
                                   n1 ->
                                 fib_seq_to_seq' B x2
                                   n1)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B
                                    x2 ^++ n1) =>
                          equiv_path (B (...) ^++ n1)
                            (B x2 ^++ (n1.+1))
                            (ap B
                               (seq_pair_shift_assoc
                                  x2 n1))
                            (e x2 ^++ x3)) n0 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n1 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n1 ->
                         fib_seq_to_seq' B x2 n1)
                        (fun x2 : {x : _ & A x} =>
                         idmap)
                        (fun (n1 : nat)
                           (e : forall
                                x2 : {x : _ & A x},
                                fib_seq_to_seq B x2 n1 ->
                                fib_seq_to_seq' B x2
                                  n1)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B
                                   x2 ^++ n1) =>
                         equiv_path
                           (B (x2 ^++) ^++ n1)
                           (B x2 ^++ (n1.+1))
                           (ap B
                              (seq_pair_shift_assoc x2
                                 n1)) (e x2 ^++ x3))
                        n0.+1 x0 x1 ^+)
                (x0 : {x : _ & A x})
                (b : fib_seq_to_seq B x0 n0.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n0) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n0) ^++)
                   (B
                      ((nat_iter n0 seq_pair_shift x0)
                       ^++) ^++)
                   (ap B
                      (ap seq_pair_shift
                         (seq_pair_shift_assoc x0 n0))))
                (p0 x0 ^++ b)) n x
       end
   |} n.+1) intro x; rapply isequiv_compose.
Defined.

(** A fibered type sequence defines a type family; Section 4. *)
Definition fib_seq_to_type_fam `{Univalence} {A} (B : FibSequence A) : Colimit A -> Type.
H: Univalence
A: Sequence
B: FibSequence A
Colimit A -> Type
Proof.
H: Univalence
A: Sequence
B: FibSequence A
Colimit A -> Type
  srapply Colimit_rec; srapply Build_Cocone.
H: Univalence
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph, A i -> Type
H: Univalence
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o A _f g == ?legs i
  -
H: Univalence
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph, A i -> Type exact (fun n a => Colimit (fib_seq_to_seq B (n;a))).
  -
H: Univalence
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (n : Graph.graph0 sequence_graph) (a : A n) =>
 Colimit (fib_seq_to_seq B (n; a))) j o A _f g ==
(fun (n : Graph.graph0 sequence_graph) (a : A n) =>
 Colimit (fib_seq_to_seq B (n; a))) i intros n m p a; destruct p; apply path_universe_uncurried.
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
Colimit (fib_seq_to_seq B (n.+1; a ^+)) <~>
Colimit (fib_seq_to_seq B (n; a))
    exact (equiv_colim_succ_seq_to_colim_seq (fib_seq_to_seq B (n;a))).
Defined.

Definition fib_seq_to_type_fam_beta_glue `{Univalence} {A} B n a :
  coe (ap (fib_seq_to_type_fam B) (glue A n a))=
  colim_succ_seq_to_colim_seq (fib_seq_to_seq B (n;a)).
H: Univalence
A: Diagram sequence_graph
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
coe (ap (fib_seq_to_type_fam B) (glue A n a)) =
colim_succ_seq_to_colim_seq (fib_seq_to_seq B (n; a))
Proof.
H: Univalence
A: Diagram sequence_graph
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
coe (ap (fib_seq_to_type_fam B) (glue A n a)) =
colim_succ_seq_to_colim_seq (fib_seq_to_seq B (n; a))
  srapply (ap _ (Colimit_rec_beta_colimp _ _ _ _ _ _) @ _).
H: Univalence
A: Diagram sequence_graph
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
coe
  (legs_comm
     {|
       legs :=
         fun (n : Graph.graph0 sequence_graph)
           (a : A n) =>
         Colimit (fib_seq_to_seq B (n; a));
       legs_comm :=
         fun (n m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n m) =>
         (fun a : A n =>
          match
            p as p0 in (_ = n0)
            return
              (Colimit
                 (fib_seq_to_seq B (n0; (A _f p0) a)) =
               Colimit (fib_seq_to_seq B (n; a)))
          with
          | 1 =>
              path_universe_uncurried
                (equiv_colim_succ_seq_to_colim_seq
                   (fib_seq_to_seq B (n; a)))
          end)
         :
         (fun (n0 : Graph.graph0 sequence_graph)
            (a : A n0) =>
          Colimit (fib_seq_to_seq B (n0; a))) m
         o A _f p ==
         (fun (n0 : Graph.graph0 sequence_graph)
            (a : A n0) =>
          Colimit (fib_seq_to_seq B (n0; a))) n
     |} n n.+1 1 a) =
colim_succ_seq_to_colim_seq (fib_seq_to_seq B (n; a))
  exact (transport_idmap_path_universe_uncurried _).
Defined.

Local Definition Delta {X Y} {x1 x2 : X} {F} (p : x1 = x2) (psi : coe (ap Y p) = F) y
  : (x1;y) = (x2;F y).
X: Type
Y: X -> Type
x1, x2: X
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
y: Y x1
(x1; y) = (x2; F y)
Proof.
X: Type
Y: X -> Type
x1, x2: X
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
y: Y x1
(x1; y) = (x2; F y)
  destruct p; destruct psi; reflexivity.
Defined.

Local Definition Delta_proj {X Y} {x1 x2 : X} {F} (p : x1 = x2) (psi : coe (ap Y p) = F) y
  : ap pr1 (Delta p psi y) = p.
X: Type
Y: X -> Type
x1, x2: X
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
y: Y x1
ap pr1 (Delta p psi y) = p
Proof.
X: Type
Y: X -> Type
x1, x2: X
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
y: Y x1
ap pr1 (Delta p psi y) = p
  destruct p; destruct psi; reflexivity.
Defined.

(** The canonical map from the sequential colimit of Sigmas to the Sigma of sequential colimits; Definition 5.1. *)
Definition seq_colim_sum_to_sum_seq_colim `{Univalence} {A} (B : FibSequence A)
  : Colimit (sig_seq B) -> sig (fib_seq_to_type_fam B).
H: Univalence
A: Sequence
B: FibSequence A
Colimit (sig_seq B) ->
{x : _ & fib_seq_to_type_fam B x}
Proof.
H: Univalence
A: Sequence
B: FibSequence A
Colimit (sig_seq B) ->
{x : _ & fib_seq_to_type_fam B x}
  srapply Colimit_rec; srapply Build_Cocone.
H: Univalence
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph,
sig_seq B i -> {x : _ & fib_seq_to_type_fam B x}
H: Univalence
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
?legs j o (sig_seq B) _f g == ?legs i
  -
H: Univalence
A: Sequence
B: FibSequence A
forall i : Graph.graph0 sequence_graph,
sig_seq B i -> {x : _ & fib_seq_to_type_fam B x} intros n [a b]; exact (inj A n a; inj (fib_seq_to_seq _ _) 0 b).
  -
H: Univalence
A: Sequence
B: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j),
(fun (n : Graph.graph0 sequence_graph)
   (X : sig_seq B n) =>
 (fun (a : A n) (b : B (n; a)) =>
  (inj A n a; inj (fib_seq_to_seq B (n; a)) 0 b)) X.1
   X.2) j o (sig_seq B) _f g ==
(fun (n : Graph.graph0 sequence_graph)
   (X : sig_seq B n) =>
 (fun (a : A n) (b : B (n; a)) =>
  (inj A n a; inj (fib_seq_to_seq B (n; a)) 0 b)) X.1
   X.2) i intros n m p [a b]; destruct p; srefine (_ @ ap _ (glue (fib_seq_to_seq _ _) 0 b)).
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
(inj A n.+1 ((a; b) ^+).1;
inj (fib_seq_to_seq B (n.+1; ((a; b) ^+).1)) 0
  ((a; b) ^+).2) =
(inj A n a; inj (fib_seq_to_seq B (n; a)) 1 b ^+)
    srapply (Delta _ (fib_seq_to_type_fam_beta_glue B n a)).
Defined.

Definition seq_colim_sum_to_sum_seq_colim_beta_glue `{Univalence} {A} B n a b :
  ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n (a;b)) =
  Delta _ (fib_seq_to_type_fam_beta_glue B n a) (inj _ _ _) @
  ap (exist _ (inj A n a)) (glue (fib_seq_to_seq _ _) 0 b).
H: Univalence
A: Diagram sequence_graph
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: (fun a : A n => B (n; a)) a
ap (seq_colim_sum_to_sum_seq_colim B)
  (glue (sig_seq B) n (a; b)) =
Delta (colimp n n.+1 1 a)
  (fib_seq_to_type_fam_beta_glue B n a)
  (inj
     (fib_seq_to_seq B
        ((n.+1; a ^+).1; (n.+1; a ^+).2)) 0 b ^+) @
ap (exist (fib_seq_to_type_fam B) (inj A n a))
  (glue (fib_seq_to_seq B (n; a)) 0 b)
Proof.
H: Univalence
A: Diagram sequence_graph
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: (fun a : A n => B (n; a)) a
ap (seq_colim_sum_to_sum_seq_colim B)
  (glue (sig_seq B) n (a; b)) =
Delta (colimp n n.+1 1 a)
  (fib_seq_to_type_fam_beta_glue B n a)
  (inj
     (fib_seq_to_seq B
        ((n.+1; a ^+).1; (n.+1; a ^+).2)) 0 b ^+) @
ap (exist (fib_seq_to_type_fam B) (inj A n a))
  (glue (fib_seq_to_seq B (n; a)) 0 b)
  srapply Colimit_rec_beta_colimp.
Defined.

(** An alternative induction principle for the sum of colimits; Lemma 5.2 and Section 6. *)
Section SeqColimitSumInd.

  Context `{Univalence} {A} (B : FibSequence A).
  Context (E : sig (fib_seq_to_type_fam B) -> Type).
  Context (e : forall n a b, E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n (a;b)))).
  Context (t : forall n a b, ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n (a;b))
    # e n.+1 (a^+) (b^+f) = e n a b).

  (** The point-point case of the nested induction; corresponds to "h" in the paper. *)
  Local Definition Q k : forall n a b, E (inj _ n a; inj _ k b).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: Graph.graph0 sequence_graph
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B ((n; a).1; (n; a).2) k),
E
  (inj A n a;
  inj (fib_seq_to_seq B ((n; a).1; (n; a).2)) k b)
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: Graph.graph0 sequence_graph
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B ((n; a).1; (n; a).2) k),
E
  (inj A n a;
  inj (fib_seq_to_seq B ((n; a).1; (n; a).2)) k b)
    induction k as [ | k h].
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) 0),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) 0 b)
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: nat
h: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) k b)
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k.+1),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) k.+1 b)
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) 0),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) 0 b) exact e.
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: nat
h: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) k b)
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k.+1),
E (inj A n a; inj (fib_seq_to_seq B (n; a)) k.+1 b) intros n a b; exact (Delta _ (fib_seq_to_type_fam_beta_glue B n a) _ # h n.+1 (a^+) b).
  Defined.

  (** The path-point case of the nested induction is just reflexivity; corresponds to "mu" in the paper. *)

  Local Definition Eta {X Y Z} {x : X} {y1 y2 : Y x} {z : sig Y} {p : y1 = y2}
    {q1 : z = (x;y1)} {q2 : z = (x;y2)} (theta : q2 = q1 @ ap _ p)
    : transport (Z o exist Y x) p o transport Z q1 == transport Z q2.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
q2: z = (x; y2)
theta: q2 = q1 @ ap (exist Y x) p
transport (Z o exist Y x) p o transport Z q1 ==
transport Z q2
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
q2: z = (x; y2)
theta: q2 = q1 @ ap (exist Y x) p
transport (Z o exist Y x) p o transport Z q1 ==
transport Z q2
    symmetry in theta; destruct theta; destruct p; simpl; destruct q1.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x: X
y1: Y x
z: {x : _ & Y x}
(fun x0 : Z z => transport Z 1 x0) ==
transport Z (1 @ 1) reflexivity.
  Defined.

  Local Definition Epsilon {X Y Z} {x1 x2 : X} {y1 y2} {F} (p : x1 = x2) {q : y1 = y2}
    {psi : coe (ap Y p) = F} {r : F y1 = F y2} (theta : ap F q = r)
    : transport (Z o exist Y x2) r o transport Z (Delta p psi y1) ==
      transport Z (Delta p psi y2) o transport (Z o exist Y x1) q.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1, y2: Y x1
F: Y x1 -> Y x2
p: x1 = x2
q: y1 = y2
psi: coe (ap Y p) = F
r: F y1 = F y2
theta: ap F q = r
transport (Z o exist Y x2) r
o transport Z (Delta p psi y1) ==
transport Z (Delta p psi y2)
o transport (Z o exist Y x1) q
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1, y2: Y x1
F: Y x1 -> Y x2
p: x1 = x2
q: y1 = y2
psi: coe (ap Y p) = F
r: F y1 = F y2
theta: ap F q = r
transport (Z o exist Y x2) r
o transport Z (Delta p psi y1) ==
transport Z (Delta p psi y2)
o transport (Z o exist Y x1) q
    destruct theta; destruct q; reflexivity.
  Defined.

  (** The point-path case of the nested induction; corresponds to "H" in the paper. *)
  Local Definition R k : forall n a b,
    transport (E o exist _ (inj A n a)) (glue _ k b) (Q k.+1 n a (b^+)) = Q k n a b.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: Graph.graph0 sequence_graph
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B ((n; a).1; (n; a).2) k),
transport
  (E o exist (fib_seq_to_type_fam B) (inj A n a))
  (glue (fib_seq_to_seq B ((n; a).1; (n; a).2)) k b)
  (Q k.+1 n a b ^+) = Q k n a b
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: Graph.graph0 sequence_graph
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B ((n; a).1; (n; a).2) k),
transport
  (E o exist (fib_seq_to_type_fam B) (inj A n a))
  (glue (fib_seq_to_seq B ((n; a).1; (n; a).2)) k b)
  (Q k.+1 n a b ^+) = Q k n a b
    induction k as [ | k h].
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) 0),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp 0 1 1 b) (Q 1 n a b ^+) =
Q 0 n a b
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: nat
h: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k k.+1 1 b)
  (Q k.+1 n a b ^+) = Q k n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k.+1),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k.+1 k.+2 1 b)
  (Q k.+2 n a b ^+) = Q k.+1 n a b
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) 0),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp 0 1 1 b) (Q 1 n a b ^+) =
Q 0 n a b intros n a b; srapply (_ @ t n a b).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: fib_seq_to_seq B (n; a) 0
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp 0 1 1 b) (Q 1 n a b ^+) =
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) (e n.+1 a ^+ b ^+f)
      srapply (Eta (seq_colim_sum_to_sum_seq_colim_beta_glue B n a b)).
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: nat
h: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k k.+1 1 b)
  (Q k.+1 n a b ^+) = Q k n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k.+1),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k.+1 k.+2 1 b)
  (Q k.+2 n a b ^+) = Q k.+1 n a b intros n a b; srefine (_ @ ap _ (h n.+1 (a^+) b)).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
k: nat
h: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : fib_seq_to_seq B (n; a) k),
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k k.+1 1 b)
  (Q k.+1 n a b ^+) = Q k n a b
n: Graph.graph0 sequence_graph
a: A n
b: fib_seq_to_seq B (n; a) k.+1
transport
  (fun x : fib_seq_to_type_fam B (inj A n a) =>
   E (inj A n a; x)) (colimp k.+1 k.+2 1 b)
  (Q k.+2 n a b ^+) =
transport E
  (Delta (colimp n n.+1 1 a)
     (fib_seq_to_type_fam_beta_glue B n a)
     (inj (fib_seq_to_seq B (n.+1; a ^+)) k b))
  (transport
     (fun x : fib_seq_to_type_fam B (inj A n.+1 a ^+)
      => E (inj A n.+1 a ^+; x)) (colimp k k.+1 1 b)
     (Q k.+1 n.+1 a ^+ b ^+))
      srapply (Epsilon (glue A n a) (colim_succ_seq_to_colim_seq_beta_glue _ _ _)).
  Defined.

  (** The point case of the nested induction; corresponds to "g" in the paper. *)
  Local Definition F n a : forall x, E (inj _ n a; x).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall x : fib_seq_to_type_fam B (inj A n a),
E (inj A n a; x)
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall x : fib_seq_to_type_fam B (inj A n a),
E (inj A n a; x)
    srapply Colimit_ind.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i : Graph.graph0 sequence_graph)
(x : fib_seq_to_seq B ((n; a).1; (n; a).2) i),
(fun
   w : Colimit (fib_seq_to_seq B ((n; a).1; (n; a).2))
 => E (inj A n a; w))
  (inj (fib_seq_to_seq B ((n; a).1; (n; a).2)) i x)
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq B ((n; a).1; (n; a).2) i),
transport
  (fun
     w : Colimit
           (fib_seq_to_seq B ((n; a).1; (n; a).2)) =>
   E (inj A n a; w)) (colimp i j g x)
  (?q j
     (((fib_seq_to_seq B ((n; a).1; (n; a).2)) _f g) x)) =
?q i x
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i : Graph.graph0 sequence_graph)
(x : fib_seq_to_seq B ((n; a).1; (n; a).2) i),
(fun
   w : Colimit (fib_seq_to_seq B ((n; a).1; (n; a).2))
 => E (inj A n a; w))
  (inj (fib_seq_to_seq B ((n; a).1; (n; a).2)) i x) exact (fun k => Q k n a).
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq B ((n; a).1; (n; a).2) i),
transport
  (fun
     w : Colimit
           (fib_seq_to_seq B ((n; a).1; (n; a).2)) =>
   E (inj A n a; w)) (colimp i j g x)
  ((fun k : Graph.graph0 sequence_graph => Q k n a) j
     (((fib_seq_to_seq B ((n; a).1; (n; a).2)) _f g) x)) =
(fun k : Graph.graph0 sequence_graph => Q k n a) i x intros k l p; destruct p; exact (R k n a).
  Defined.

  Local Definition F_beta_glue n a b : apD (F n a) (glue _ 0 b) = R 0 n a b.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: fib_seq_to_seq B ((n; a).1; (n; a).2) 0
apD (F n a)
  (glue (fib_seq_to_seq B ((n; a).1; (n; a).2)) 0 b) =
R 0 n a b
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: fib_seq_to_seq B ((n; a).1; (n; a).2) 0
apD (F n a)
  (glue (fib_seq_to_seq B ((n; a).1; (n; a).2)) 0 b) =
R 0 n a b
    srapply Colimit_ind_beta_colimp.
  Defined.

  Local Definition Phi {X Y Z} {x1 x2 : X} {y1 y2} {F} (p : x1 = x2) {q : y1 = y2}
    {psi : coe (ap Y p) = F} {G1 : forall y, Z (x1;y)} {G2 : forall y, Z (x2;y)}
    {r : F y1 = F y2} (theta : ap F q = r)
    : forall u1 u2,
      apD G2 r @ u2 = ap (transport _ r) u1 @ Epsilon p theta (G1 y1) @
                      ap (transport Z (Delta p psi y2)) (apD G1 q)
      -> transport (fun y => G2 (F y) = Delta p psi y # G1 y) q u1 = u2.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1, y2: Y x1
F: Y x1 -> Y x2
p: x1 = x2
q: y1 = y2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
r: F y1 = F y2
theta: ap F q = r
forall
(u1 : G2 (F y1) = transport Z (Delta p psi y1) (G1 y1))
(u2 : G2 (F y2) = transport Z (Delta p psi y2) (G1 y2)),
apD G2 r @ u2 =
(ap (transport (fun x : Y x2 => Z (x2; x)) r) u1 @
 Epsilon p theta (G1 y1)) @
ap (transport Z (Delta p psi y2)) (apD G1 q) ->
transport
  (fun y : Y x1 =>
   G2 (F y) = transport Z (Delta p psi y) (G1 y)) q u1 =
u2
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1, y2: Y x1
F: Y x1 -> Y x2
p: x1 = x2
q: y1 = y2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
r: F y1 = F y2
theta: ap F q = r
forall
(u1 : G2 (F y1) = transport Z (Delta p psi y1) (G1 y1))
(u2 : G2 (F y2) = transport Z (Delta p psi y2) (G1 y2)),
apD G2 r @ u2 =
(ap (transport (fun x : Y x2 => Z (x2; x)) r) u1 @
 Epsilon p theta (G1 y1)) @
ap (transport Z (Delta p psi y2)) (apD G1 q) ->
transport
  (fun y : Y x1 =>
   G2 (F y) = transport Z (Delta p psi y) (G1 y)) q u1 =
u2
    destruct theta; destruct q; intros u1 u2; rewrite ap_idmap, !concat_p1.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1: Y x1
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
u1, u2: G2 (F y1) = transport Z (Delta p psi y1) (G1 y1)
apD G2 (ap F 1) @ u2 = u1 ->
transport
  (fun y : Y x1 =>
   G2 (F y) = transport Z (Delta p psi y) (G1 y)) 1 u1 =
u2 simpl.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
y1: Y x1
F: Y x1 -> Y x2
p: x1 = x2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
u1, u2: G2 (F y1) = transport Z (Delta p psi y1) (G1 y1)
1 @ u2 = u1 -> u1 = u2
    intro s; destruct s; exact (concat_1p _).
  Defined.

  (** The path case of the nested induction; corresponds to "omega" in the paper. *)
  Local Definition G n a : forall y,
    F n a _ = Delta _ (fib_seq_to_type_fam_beta_glue B n a) y # F n.+1 (a^+) y.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall y : fib_seq_to_type_fam B (inj A n.+1 a ^+),
F n a
  (colim_succ_seq_to_colim_seq
     (fib_seq_to_seq B (n; a)) y) =
transport E
  (Delta (colimp n n.+1 1 a)
     (fib_seq_to_type_fam_beta_glue B n a) y)
  (F n.+1 a ^+ y)
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall y : fib_seq_to_type_fam B (inj A n.+1 a ^+),
F n a
  (colim_succ_seq_to_colim_seq
     (fib_seq_to_seq B (n; a)) y) =
transport E
  (Delta (colimp n n.+1 1 a)
     (fib_seq_to_type_fam_beta_glue B n a) y)
  (F n.+1 a ^+ y)
    srapply Colimit_ind.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i : Graph.graph0 sequence_graph)
(x : fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
       i),
(fun
   w : Colimit
         (fib_seq_to_seq B
            ((n.+1; a ^+).1; (n.+1; a ^+).2)) =>
 F n a
   (colim_succ_seq_to_colim_seq
      (fib_seq_to_seq B (n; a)) w) =
 transport E
   (Delta (colimp n n.+1 1 a)
      (fib_seq_to_type_fam_beta_glue B n a) w)
   (F n.+1 a ^+ w))
  (inj
     (fib_seq_to_seq B
        ((n.+1; a ^+).1; (n.+1; a ^+).2)) i x)
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
       i),
transport
  (fun
     w : Colimit
           (fib_seq_to_seq B
              ((n.+1; a ^+).1; (n.+1; a ^+).2)) =>
   F n a
     (colim_succ_seq_to_colim_seq
        (fib_seq_to_seq B (n; a)) w) =
   transport E
     (Delta (colimp n n.+1 1 a)
        (fib_seq_to_type_fam_beta_glue B n a) w)
     (F n.+1 a ^+ w)) (colimp i j g x)
  (?q j
     (((fib_seq_to_seq B
          ((n.+1; a ^+).1; (n.+1; a ^+).2)) _f g) x)) =
?q i x
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i : Graph.graph0 sequence_graph)
(x : fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
       i),
(fun
   w : Colimit
         (fib_seq_to_seq B
            ((n.+1; a ^+).1; (n.+1; a ^+).2)) =>
 F n a
   (colim_succ_seq_to_colim_seq
      (fib_seq_to_seq B (n; a)) w) =
 transport E
   (Delta (colimp n n.+1 1 a)
      (fib_seq_to_type_fam_beta_glue B n a) w)
   (F n.+1 a ^+ w))
  (inj
     (fib_seq_to_seq B
        ((n.+1; a ^+).1; (n.+1; a ^+).2)) i x) exact (fun k b => idpath).
    -
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
       i),
transport
  (fun
     w : Colimit
           (fib_seq_to_seq B
              ((n.+1; a ^+).1; (n.+1; a ^+).2)) =>
   F n a
     (colim_succ_seq_to_colim_seq
        (fib_seq_to_seq B (n; a)) w) =
   transport E
     (Delta (colimp n n.+1 1 a)
        (fib_seq_to_type_fam_beta_glue B n a) w)
     (F n.+1 a ^+ w)) (colimp i j g x)
  ((fun (k : Graph.graph0 sequence_graph)
      (b : fib_seq_to_seq B
             ((n.+1; a ^+).1; (n.+1; a ^+).2) k) => 1)
     j
     (((fib_seq_to_seq B
          ((n.+1; a ^+).1; (n.+1; a ^+).2)) _f g) x)) =
(fun (k : Graph.graph0 sequence_graph)
   (b : fib_seq_to_seq B
          ((n.+1; a ^+).1; (n.+1; a ^+).2) k) => 1) i
  x intros k l p b; destruct p.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
k: Graph.graph0 sequence_graph
b: fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
  k
transport
  (fun w : Colimit (fib_seq_to_seq B (n.+1; a ^+)) =>
   F n a
     (colim_succ_seq_to_colim_seq
        (fib_seq_to_seq B (n; a)) w) =
   transport E
     (Delta (colimp n n.+1 1 a)
        (fib_seq_to_type_fam_beta_glue B n a) w)
     (F n.+1 a ^+ w)) (colimp k k.+1 1 b) 1 = 1
      snapply (Phi (glue A n a) (colim_succ_seq_to_colim_seq_beta_glue _ _ _)).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
k: Graph.graph0 sequence_graph
b: fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
  k
apD (F n a) (colimp k.+1 k.+2 1 b) @ 1 =
(ap
   (transport
      (fun x : fib_seq_to_type_fam B (inj A n a) =>
       E (inj A n a; x)) (colimp k.+1 k.+2 1 b)) 1 @
 Epsilon (glue A n a)
   (colim_succ_seq_to_colim_seq_beta_glue
      (fib_seq_to_seq B (n; a)) k b)
   (F n.+1 a ^+
      (inj (succ_seq (fib_seq_to_seq B (n; a))) k.+1
         b ^+))) @
ap
  (transport E
     (Delta (glue A n a)
        (fib_seq_to_type_fam_beta_glue B n a)
        (inj (succ_seq (fib_seq_to_seq B (n; a))) k b)))
  (apD (F n.+1 a ^+) (colimp k k.+1 1 b))
      rewrite (Colimit_ind_beta_colimp _ (fun k => Q k n a) _ _ _ idpath).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
k: Graph.graph0 sequence_graph
b: fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
  k
R k.+1 n a b @ 1 =
(ap
   (transport
      (fun x : fib_seq_to_type_fam B (inj A n a) =>
       E (inj A n a; x)) (colimp k.+1 k.+2 1 b)) 1 @
 Epsilon (colimp n n.+1 1 a)
   (colim_succ_seq_to_colim_seq_beta_glue
      (fib_seq_to_seq B (n; a)) k b)
   (F n.+1 a ^+
      (inj (succ_seq (fib_seq_to_seq B (n; a))) k.+1
         b ^+))) @
ap
  (transport E
     (Delta (colimp n n.+1 1 a)
        (fib_seq_to_type_fam_beta_glue B n a)
        (inj (succ_seq (fib_seq_to_seq B (n; a))) k b)))
  (apD (F n.+1 a ^+) (colimp k k.+1 1 b))
      rewrite (Colimit_ind_beta_colimp _ (fun k => Q k n.+1 a^+) _ _ _ idpath).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
k: Graph.graph0 sequence_graph
b: fib_seq_to_seq B ((n.+1; a ^+).1; (n.+1; a ^+).2)
  k
R k.+1 n a b @ 1 =
(ap
   (transport
      (fun x : fib_seq_to_type_fam B (inj A n a) =>
       E (inj A n a; x)) (colimp k.+1 k.+2 1 b)) 1 @
 Epsilon (colimp n n.+1 1 a)
   (colim_succ_seq_to_colim_seq_beta_glue
      (fib_seq_to_seq B (n; a)) k b)
   (F n.+1 a ^+
      (inj (succ_seq (fib_seq_to_seq B (n; a))) k.+1
         b ^+))) @
ap
  (transport E
     (Delta (colimp n n.+1 1 a)
        (fib_seq_to_type_fam_beta_glue B n a)
        (inj (succ_seq (fib_seq_to_seq B (n; a))) k b)))
  (R k n.+1 a ^+ b)
      rewrite concat_p1, concat_1p; reflexivity.
  Defined.

  Local Definition I {X Y Z} {x1 x2 : X} {p : x1 = x2} {F} (psi : coe (ap Y p) = F) {G1 G2}
    : transport (fun x => forall y, Z (x;y)) p G1 = G2 <~>
      forall y, G2 (F y) = Delta p psi y # G1 y.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
p: x1 = x2
F: Y x1 -> Y x2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
transport (fun x : X => forall y : Y x, Z (x; y)) p G1 =
G2 <~>
(forall y : Y x1,
 G2 (F y) = transport Z (Delta p psi y) (G1 y))
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
p: x1 = x2
F: Y x1 -> Y x2
psi: coe (ap Y p) = F
G1: forall y : Y x1, Z (x1; y)
G2: forall y : Y x2, Z (x2; y)
transport (fun x : X => forall y : Y x, Z (x; y)) p G1 =
G2 <~>
(forall y : Y x1,
 G2 (F y) = transport Z (Delta p psi y) (G1 y))
    destruct p; destruct psi.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1: X
G1, G2: forall y : Y x1, Z (x1; y)
transport (fun x : X => forall y : Y x, Z (x; y)) 1 G1 =
G2 <~>
(forall y : Y x1,
 G2 (equiv_path (Y x1) (Y x1) (ap Y 1) y) =
 transport Z (Delta 1 1 y) (G1 y))
    exact (transitivity (equiv_path_inverse _ _) (equiv_apD10 _ _ _)).
  Defined.

  (** The alternative induction rule in curried form; corresponds to curried "G" in
      the paper. *)
  Definition seq_colim_sum_ind_cur : forall x y, E (x;y).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (x : Colimit A) (y : fib_seq_to_type_fam B x),
E (x; y)
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (x : Colimit A) (y : fib_seq_to_type_fam B x),
E (x; y)
    srapply (Colimit_ind _ F); intros n m p a; destruct p.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
transport
  (fun w : Colimit A =>
   forall y : fib_seq_to_type_fam B w, E (w; y))
  (colimp n n.+1 1 a) (F n.+1 a ^+) = F n a
    exact ((I (fib_seq_to_type_fam_beta_glue B n a))^-1 (G n a)).
  Defined.

  (** The computation rule for the alternative induction rule in curried form. *)
  Definition seq_colim_sum_ind_cur_beta_glue n a :
    I (fib_seq_to_type_fam_beta_glue B n a) (apD seq_colim_sum_ind_cur (glue _ n a)) = G n a.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
I (fib_seq_to_type_fam_beta_glue B n a)
  (apD seq_colim_sum_ind_cur (glue A n a)) = G n a
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
I (fib_seq_to_type_fam_beta_glue B n a)
  (apD seq_colim_sum_ind_cur (glue A n a)) = G n a
    apply moveR_equiv_M; srapply Colimit_ind_beta_colimp.
  Defined.

  (** The alternative induction rule; corresponds to "G" in the paper. *)
  Definition seq_colim_sum_ind : forall x, E x.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall x : {x : _ & fib_seq_to_type_fam B x}, E x
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall x : {x : _ & fib_seq_to_type_fam B x}, E x
    intros [x y]; apply seq_colim_sum_ind_cur.
  Defined.

  Local Definition Xi {X Y Z} G {x : X} {y1 y2 : Y x} {z : sig Y} {p : y1 = y2}
    {q1 : z = (x;y1)} {q2 : z = (x;y2)} (theta : q2 = q1 @ ap _ p)
    : apD (G o exist Y x) p =
      ap (transport (Z o exist Y x) p) (apD G q1)^ @ Eta theta (G z) @ apD G q2.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
G: forall x0 : {x : _ & Y x}, Z x0
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
q2: z = (x; y2)
theta: q2 = q1 @ ap (exist Y x) p
apD (G o exist Y x) p =
(ap (transport (Z o exist Y x) p) (apD G q1)^ @
 Eta theta (G z)) @ apD G q2
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
G: forall x0 : {x : _ & Y x}, Z x0
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
q2: z = (x; y2)
theta: q2 = q1 @ ap (exist Y x) p
apD (G o exist Y x) p =
(ap (transport (Z o exist Y x) p) (apD G q1)^ @
 Eta theta (G z)) @ apD G q2
    revert theta; srapply (equiv_ind (equiv_path_inverse _ _)).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
G: forall x0 : {x : _ & Y x}, Z x0
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
q2: z = (x; y2)
forall x0 : q1 @ ap (exist Y x) p = q2,
(fun y : q2 = q1 @ ap (exist Y x) p =>
 apD (G o exist Y x) p =
 (ap (transport (Z o exist Y x) p) (apD G q1)^ @
  Eta y (G z)) @ apD G q2)
  (equiv_path_inverse (q1 @ ap (exist Y x) p) q2 x0) intro s; destruct s.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
G: forall x0 : {x : _ & Y x}, Z x0
x: X
y1, y2: Y x
z: {x : _ & Y x}
p: y1 = y2
q1: z = (x; y1)
apD (fun x0 : Y x => G (x; x0)) p =
(ap (transport (fun x0 : Y x => Z (x; x0)) p)
   (apD G q1)^ @
 Eta
   (equiv_path_inverse (q1 @ ap (exist Y x) p)
      (q1 @ ap (exist Y x) p) 1) (G z)) @
apD G (q1 @ ap (exist Y x) p)
    revert q1; srapply (equiv_ind (equiv_path_inverse _ _)); intro s; destruct s.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
G: forall x0 : {x : _ & Y x}, Z x0
x: X
y1, y2: Y x
p: y1 = y2
apD (fun x0 : Y x => G (x; x0)) p =
(ap (transport (fun x0 : Y x => Z (x; x0)) p)
   (apD G (equiv_path_inverse (x; y1) (x; y1) 1))^ @
 Eta
   (equiv_path_inverse
      (equiv_path_inverse (x; y1) (x; y1) 1 @
       ap (exist Y x) p)
      (equiv_path_inverse (x; y1) (x; y1) 1 @
       ap (exist Y x) p) 1) (G (x; y1))) @
apD G
  (equiv_path_inverse (x; y1) (x; y1) 1 @
   ap (exist Y x) p)
    destruct p; reflexivity.
  Defined.

  Local Definition Mu {X Y Z} {x1 x2 : X} (p : x1 = x2) {F} (G : forall z, Z z)
    {psi : coe (ap Y p) = F} {q} (theta : I psi (apD (fun x y => G (x;y)) p) = q) y
    : apD G (Delta p psi y) = (q y)^.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
p: x1 = x2
F: Y x1 -> Y x2
G: forall z : {x : _ & Y x}, Z z
psi: coe (ap Y p) = F
q: forall y : Y x1,
(fun y0 : Y x2 => G (x2; y0)) (F y) =
transport Z (Delta p psi y)
  ((fun y0 : Y x1 => G (x1; y0)) y)
theta: I psi
  (apD (fun (x : X) (y : Y x) => G (x; y)) p) =
q
y: Y x1
apD G (Delta p psi y) = (q y)^
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
X: Type
Y: X -> Type
Z: {x : _ & Y x} -> Type
x1, x2: X
p: x1 = x2
F: Y x1 -> Y x2
G: forall z : {x : _ & Y x}, Z z
psi: coe (ap Y p) = F
q: forall y : Y x1,
(fun y0 : Y x2 => G (x2; y0)) (F y) =
transport Z (Delta p psi y)
  ((fun y0 : Y x1 => G (x1; y0)) y)
theta: I psi
  (apD (fun (x : X) (y : Y x) => G (x; y)) p) =
q
y: Y x1
apD G (Delta p psi y) = (q y)^
    destruct p; destruct psi; destruct theta; reflexivity.
  Defined.

  (** The computation rule for the alternative induction rule. *)
  Definition seq_colim_sum_ind_beta_glue : forall n a b,
    apD seq_colim_sum_ind (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n _)) =
    t n a b.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)),
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)),
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
    intros n a b; pose (h := F_beta_glue n a b).
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
h:= F_beta_glue n a b: apD (F n a)
  (glue (fib_seq_to_seq B ((n; a).1; (n; a).2)) 0
     b) = R 0 n a b
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
    rewrite (Xi seq_colim_sum_ind (seq_colim_sum_to_sum_seq_colim_beta_glue B n a b)) in h.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
h: (ap
   (transport
      (fun x0 : fib_seq_to_type_fam B (inj A n a)
       => E (inj A n a; x0)) (colimp 0 1 1 b))
   (apD seq_colim_sum_ind
      (Delta (colimp n n.+1 1 a)
         (fib_seq_to_type_fam_beta_glue B n a)
         (inj (fib_seq_to_seq B (n.+1; a ^+)) 0
            b ^+)))^ @
 Eta
   (seq_colim_sum_to_sum_seq_colim_beta_glue B n a
      b)
   (seq_colim_sum_ind
      (seq_colim_sum_to_sum_seq_colim B
         (inj (sig_seq B) n.+1 (a; b) ^+)))) @
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (colimp n n.+1 1 (a; b))) = R 0 n a b
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
    rewrite (Mu (glue _ n a) seq_colim_sum_ind (seq_colim_sum_ind_cur_beta_glue n a)) in h.
H: Univalence
A: Sequence
B: FibSequence A
E: {x : _ & fib_seq_to_type_fam B x} -> Type
e: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
E
  (seq_colim_sum_to_sum_seq_colim B
     (inj (sig_seq B) n (a; b)))
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (e n.+1 a ^+ b ^+f) = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
h: (ap
   (transport
      (fun x0 : fib_seq_to_type_fam B (inj A n a)
       => E (inj A n a; x0)) (colimp 0 1 1 b))
   ((G n a
       (inj (fib_seq_to_seq B (n.+1; a ^+)) 0 b ^+))^)^ @
 Eta
   (seq_colim_sum_to_sum_seq_colim_beta_glue B n a
      b)
   (seq_colim_sum_ind
      (seq_colim_sum_to_sum_seq_colim B
         (inj (sig_seq B) n.+1 (a; b) ^+)))) @
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (colimp n n.+1 1 (a; b))) = R 0 n a b
apD seq_colim_sum_ind
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
    rewrite concat_1p in h; exact (cancelL _ _ _ h).
  Defined.

End SeqColimitSumInd.

(** An alternative recursion principle for the sum of colimits; Lemma 5.3. *)
Section SeqColimitSumRec.

  Context `{Univalence} {A} (B : FibSequence A).
  Context E (e : forall n a, B (n;a) -> E).
  Context (t : forall n a (b : B (n;a)), e n.+1 (a^+) (b^+f) = e n a b).

  Definition seq_colim_sum_rec : sig (fib_seq_to_type_fam B)-> E.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
e: forall (n : Graph.graph0 sequence_graph)
(a : A n), B (n; a) -> E
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), e n.+1 a ^+ b ^+f = e n a b
{x : _ & fib_seq_to_type_fam B x} -> E
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
e: forall (n : Graph.graph0 sequence_graph)
(a : A n), B (n; a) -> E
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), e n.+1 a ^+ b ^+f = e n a b
{x : _ & fib_seq_to_type_fam B x} -> E
    exact (seq_colim_sum_ind B _ e (fun n a b => transport_const _ _ @ t n a b)).
  Defined.

  Definition seq_colim_sum_rec_beta_glue : forall n a b,
    ap seq_colim_sum_rec (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n (a;b))) =
    t n a b.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
e: forall (n : Graph.graph0 sequence_graph)
(a : A n), B (n; a) -> E
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), e n.+1 a ^+ b ^+f = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
ap seq_colim_sum_rec
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
  Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
e: forall (n : Graph.graph0 sequence_graph)
(a : A n), B (n; a) -> E
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), e n.+1 a ^+ b ^+f = e n a b
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : (fun a0 : A n => B (n; a0)) a),
ap seq_colim_sum_rec
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) = t n a b
    intros n a b; srapply (cancelL _ _ _ ((apD_const _ _)^ @ _)).
H: Univalence
A: Sequence
B: FibSequence A
E: Type
e: forall (n : Graph.graph0 sequence_graph)
(a : A n), B (n; a) -> E
t: forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), e n.+1 a ^+ b ^+f = e n a b
n: Graph.graph0 sequence_graph
a: A n
b: (fun a : A n => B (n; a)) a
apD seq_colim_sum_rec
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b))) =
transport_const
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  (seq_colim_sum_rec
     (seq_colim_sum_to_sum_seq_colim B
        (inj (sig_seq B) n.+1 (a; b) ^+))) @ t n a b
    srapply seq_colim_sum_ind_beta_glue.
  Defined.

End SeqColimitSumRec.

(** Lemma 5.4. *)
Definition seq_colimit_sum_uniq `{Univalence} {A} (B : FibSequence A) E
  (F G : sig (fib_seq_to_type_fam B) -> E)
  : F o (seq_colim_sum_to_sum_seq_colim B) == G o (seq_colim_sum_to_sum_seq_colim B) ->
    F == G.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
F, G: {x : _ & fib_seq_to_type_fam B x} -> E
F o seq_colim_sum_to_sum_seq_colim B ==
G o seq_colim_sum_to_sum_seq_colim B -> F == G
Proof.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
F, G: {x : _ & fib_seq_to_type_fam B x} -> E
F o seq_colim_sum_to_sum_seq_colim B ==
G o seq_colim_sum_to_sum_seq_colim B -> F == G
  intro h; srapply (seq_colim_sum_ind B _ (fun _ _ _ => h _)); intros n a b.
H: Univalence
A: Sequence
B: FibSequence A
E: Type
F, G: {x : _ & fib_seq_to_type_fam B x} -> E
h: F o seq_colim_sum_to_sum_seq_colim B ==
G o seq_colim_sum_to_sum_seq_colim B
n: Graph.graph0 sequence_graph
a: A n
b: (fun a : A n => B (n; a)) a
transport
  (fun x : {x : _ & fib_seq_to_type_fam B x} =>
   F x = G x)
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (glue (sig_seq B) n (a; b)))
  ((fun (n : Graph.graph0 sequence_graph) (a : A n)
      (b : (fun a0 : A n => B (n; a0)) a) =>
    h (inj (sig_seq B) n (a; b))) n.+1 a ^+ b ^+f) =
(fun (n : Graph.graph0 sequence_graph) (a : A n)
   (b : (fun a0 : A n => B (n; a0)) a) =>
 h (inj (sig_seq B) n (a; b))) n a b
  srapply ((transport_compose _ _ _ _)^ @ _); exact (apD h (glue (sig_seq B) n (a;b))).
Defined.

(** The canonical map from the sequential colimit of Sigmas to the Sigma of sequential colimits is an equivalence; Theorem 5.1. *)
Instance isequiv_seq_colim_sum_to_sum_seq_colim `{Univalence} {A} (B : FibSequence A)
  : IsEquiv (seq_colim_sum_to_sum_seq_colim B).
H: Univalence
A: Sequence
B: FibSequence A
IsEquiv (seq_colim_sum_to_sum_seq_colim B)
Proof.
H: Univalence
A: Sequence
B: FibSequence A
IsEquiv (seq_colim_sum_to_sum_seq_colim B)
  assert (L : {G : _ & G o seq_colim_sum_to_sum_seq_colim B == idmap}).
H: Univalence
A: Sequence
B: FibSequence A
{G
: {x : _ & fib_seq_to_type_fam B x} ->
  GraphQuotient.GraphQuotient.GraphQuotient
    (fun a b : {x : _ & sig_seq B x} =>
     {x
     : {x : {x : _ & sig_seq B x} &
       {j : Graph.graph0 sequence_graph &
       Graph.graph1 sequence_graph x.1 j}} &
     ((x.1 = a) *
      (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
&
(fun x : Colimit (sig_seq B) =>
 G (seq_colim_sum_to_sum_seq_colim B x)) == idmap}
H: Univalence
A: Sequence
B: FibSequence A
L: {G
: {x : _ & fib_seq_to_type_fam B x} ->
  GraphQuotient.GraphQuotient.GraphQuotient
    (fun a b : {x : _ & sig_seq B x} =>
     {x
     : {x : {x : _ & sig_seq B x} &
       {j : Graph.graph0 sequence_graph &
       Graph.graph1 sequence_graph x.1 j}} &
     (((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        => t.1) x = a) *
      ((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        =>
        ((t.2).1;
        ((sig_seq B) _f (t.2).2) (t.1).2)) x = b))%type})
& G o seq_colim_sum_to_sum_seq_colim B == idmap}
IsEquiv (seq_colim_sum_to_sum_seq_colim B)
  -
H: Univalence
A: Sequence
B: FibSequence A
{G
: {x : _ & fib_seq_to_type_fam B x} ->
  GraphQuotient.GraphQuotient.GraphQuotient
    (fun a b : {x : _ & sig_seq B x} =>
     {x
     : {x : {x : _ & sig_seq B x} &
       {j : Graph.graph0 sequence_graph &
       Graph.graph1 sequence_graph x.1 j}} &
     ((x.1 = a) *
      (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
&
(fun x : Colimit (sig_seq B) =>
 G (seq_colim_sum_to_sum_seq_colim B x)) == idmap} srapply (_;_).
H: Univalence
A: Sequence
B: FibSequence A
{x : _ & fib_seq_to_type_fam B x} ->
GraphQuotient.GraphQuotient.GraphQuotient
  (fun a b : {x : _ & sig_seq B x} =>
   {x
   : {x : {x : _ & sig_seq B x} &
     {j : Graph.graph0 sequence_graph &
     Graph.graph1 sequence_graph x.1 j}} &
   ((x.1 = a) *
    (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
H: Univalence
A: Sequence
B: FibSequence A
(fun
   G : {x : _ & fib_seq_to_type_fam B x} ->
       GraphQuotient.GraphQuotient.GraphQuotient
         (fun a b : {x : _ & sig_seq B x} =>
          {x
          : {x : {x : _ & sig_seq B x} &
            {j : Graph.graph0 sequence_graph &
            Graph.graph1 sequence_graph x.1 j}} &
          ((x.1 = a) *
           (((x.2).1;
            ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
 =>
 (fun x : Colimit (sig_seq B) =>
  G (seq_colim_sum_to_sum_seq_colim B x)) == idmap)
  ?proj1
    +
H: Univalence
A: Sequence
B: FibSequence A
{x : _ & fib_seq_to_type_fam B x} ->
GraphQuotient.GraphQuotient.GraphQuotient
  (fun a b : {x : _ & sig_seq B x} =>
   {x
   : {x : {x : _ & sig_seq B x} &
     {j : Graph.graph0 sequence_graph &
     Graph.graph1 sequence_graph x.1 j}} &
   ((x.1 = a) *
    (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type}) srapply seq_colim_sum_rec.
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph) (a : A n),
B (n; a) ->
GraphQuotient.GraphQuotient.GraphQuotient
  (fun a0 b : {x : _ & sig_seq B x} =>
   {x
   : {x : {x : _ & sig_seq B x} &
     {j : Graph.graph0 sequence_graph &
     Graph.graph1 sequence_graph x.1 j}} &
   ((x.1 = a0) *
    (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)), ?e n.+1 a ^+ b ^+f = ?e n a b
      *
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph) (a : A n),
B (n; a) ->
GraphQuotient.GraphQuotient.GraphQuotient
  (fun a0 b : {x : _ & sig_seq B x} =>
   {x
   : {x : {x : _ & sig_seq B x} &
     {j : Graph.graph0 sequence_graph &
     Graph.graph1 sequence_graph x.1 j}} &
   ((x.1 = a0) *
    (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type}) exact (fun n a b => inj (sig_seq B) n (a;b)).
      *
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph) (a : A n)
(b : B (n; a)),
(fun (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
   (b0 : B (n0; a0)) => inj (sig_seq B) n0 (a0; b0))
  n.+1 a ^+ b ^+f =
(fun (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
   (b0 : B (n0; a0)) => inj (sig_seq B) n0 (a0; b0)) n
  a b exact (fun n a b => glue (sig_seq B) n (a;b)).
    +
H: Univalence
A: Sequence
B: FibSequence A
(fun
   G : {x : _ & fib_seq_to_type_fam B x} ->
       GraphQuotient.GraphQuotient.GraphQuotient
         (fun a b : {x : _ & sig_seq B x} =>
          {x
          : {x : {x : _ & sig_seq B x} &
            {j : Graph.graph0 sequence_graph &
            Graph.graph1 sequence_graph x.1 j}} &
          ((x.1 = a) *
           (((x.2).1;
            ((sig_seq B) _f (x.2).2) (x.1).2) = b))%type})
 =>
 (fun x : Colimit (sig_seq B) =>
  G (seq_colim_sum_to_sum_seq_colim B x)) == idmap)
  (seq_colim_sum_rec B
     (GraphQuotient.GraphQuotient.GraphQuotient
        (fun a b : {x : _ & sig_seq B x} =>
         {x
         : {x : {x : _ & sig_seq B x} &
           {j : Graph.graph0 sequence_graph &
           Graph.graph1 sequence_graph x.1 j}} &
         ((x.1 = a) *
          (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) =
           b))%type}))
     (fun (n : Graph.graph0 sequence_graph) (a : A n)
        (b : B (n; a)) => inj (sig_seq B) n (a; b))
     (fun (n : Graph.graph0 sequence_graph) (a : A n)
        (b : B (n; a)) => glue (sig_seq B) n (a; b))) srapply seq_colimit_uniq.
H: Univalence
A: Sequence
B: FibSequence A
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (sig_seq B) =>
 seq_colim_sum_rec B
   (GraphQuotient.GraphQuotient.GraphQuotient
      (fun a b : {x : _ & sig_seq B x} =>
       {x0
       : {x0 : {x : _ & sig_seq B x} &
         {j : Graph.graph0 sequence_graph &
         Graph.graph1 sequence_graph x0.1 j}} &
       ((x0.1 = a) *
        (((x0.2).1;
         ((sig_seq B) _f (x0.2).2) (x0.1).2) = b))%type}))
   (fun (n0 : Graph.graph0 sequence_graph) (a : A n0)
      (b : B (n0; a)) => inj (sig_seq B) n0 (a; b))
   (fun (n0 : Graph.graph0 sequence_graph) (a : A n0)
      (b : B (n0; a)) => glue (sig_seq B) n0 (a; b))
   (seq_colim_sum_to_sum_seq_colim B x))
o inj (sig_seq B) n == idmap o inj (sig_seq B) n
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph)
(a : sig_seq B n),
ap
  (fun x : Colimit (sig_seq B) =>
   seq_colim_sum_rec B
     (GraphQuotient.GraphQuotient.GraphQuotient
        (fun a0 b : {x : _ & sig_seq B x} =>
         {x0
         : {x0 : {x : _ & sig_seq B x} &
           {j : Graph.graph0 sequence_graph &
           Graph.graph1 sequence_graph x0.1 j}} &
         ((x0.1 = a0) *
          (((x0.2).1;
           ((sig_seq B) _f (x0.2).2) (x0.1).2) = b))%type}))
     (fun (n0 : Graph.graph0 sequence_graph)
        (a0 : A n0) (b : B (n0; a0)) =>
      inj (sig_seq B) n0 (a0; b))
     (fun (n0 : Graph.graph0 sequence_graph)
        (a0 : A n0) (b : B (n0; a0)) =>
      glue (sig_seq B) n0 (a0; b))
     (seq_colim_sum_to_sum_seq_colim B x))
  (glue (sig_seq B) n a) @ ?h n a =
?h n.+1 a ^+ @ ap idmap (glue (sig_seq B) n a)
      *
H: Univalence
A: Sequence
B: FibSequence A
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (sig_seq B) =>
 seq_colim_sum_rec B
   (GraphQuotient.GraphQuotient.GraphQuotient
      (fun a b : {x : _ & sig_seq B x} =>
       {x0
       : {x0 : {x : _ & sig_seq B x} &
         {j : Graph.graph0 sequence_graph &
         Graph.graph1 sequence_graph x0.1 j}} &
       ((x0.1 = a) *
        (((x0.2).1;
         ((sig_seq B) _f (x0.2).2) (x0.1).2) = b))%type}))
   (fun (n0 : Graph.graph0 sequence_graph) (a : A n0)
      (b : B (n0; a)) => inj (sig_seq B) n0 (a; b))
   (fun (n0 : Graph.graph0 sequence_graph) (a : A n0)
      (b : B (n0; a)) => glue (sig_seq B) n0 (a; b))
   (seq_colim_sum_to_sum_seq_colim B x))
o inj (sig_seq B) n == idmap o inj (sig_seq B) n exact (fun n a => idpath).
      *
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph)
(a : sig_seq B n),
ap
  (fun x : Colimit (sig_seq B) =>
   seq_colim_sum_rec B
     (GraphQuotient.GraphQuotient.GraphQuotient
        (fun a0 b : {x : _ & sig_seq B x} =>
         {x0
         : {x0 : {x : _ & sig_seq B x} &
           {j : Graph.graph0 sequence_graph &
           Graph.graph1 sequence_graph x0.1 j}} &
         ((x0.1 = a0) *
          (((x0.2).1;
           ((sig_seq B) _f (x0.2).2) (x0.1).2) = b))%type}))
     (fun (n0 : Graph.graph0 sequence_graph)
        (a0 : A n0) (b : B (n0; a0)) =>
      inj (sig_seq B) n0 (a0; b))
     (fun (n0 : Graph.graph0 sequence_graph)
        (a0 : A n0) (b : B (n0; a0)) =>
      glue (sig_seq B) n0 (a0; b))
     (seq_colim_sum_to_sum_seq_colim B x))
  (glue (sig_seq B) n a) @
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : sig_seq B n0) => 1) n a =
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : sig_seq B n0) => 1) n.+1 a ^+ @
ap idmap (glue (sig_seq B) n a) intros n a; rewrite concat_1p, concat_p1, ap_compose, ap_idmap.
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: sig_seq B n
ap
  (seq_colim_sum_rec B
     (GraphQuotient.GraphQuotient.GraphQuotient
        (fun a b : {x : _ & sig_seq B x} =>
         {x
         : {x : {x : _ & sig_seq B x} &
           {j : Graph.graph0 sequence_graph &
           Graph.graph1 sequence_graph x.1 j}} &
         ((x.1 = a) *
          (((x.2).1; ((sig_seq B) _f (x.2).2) (x.1).2) =
           b))%type}))
     (fun (n : Graph.graph0 sequence_graph) (a : A n)
        (b : B (n; a)) => inj (sig_seq B) n (a; b))
     (fun (n : Graph.graph0 sequence_graph) (a : A n)
        (b : B (n; a)) => colimp n n.+1 1 (a; b)))
  (ap (seq_colim_sum_to_sum_seq_colim B)
     (colimp n n.+1 1 a)) = colimp n n.+1 1 a
        rewrite seq_colim_sum_rec_beta_glue; reflexivity.
  -
H: Univalence
A: Sequence
B: FibSequence A
L: {G
: {x : _ & fib_seq_to_type_fam B x} ->
  GraphQuotient.GraphQuotient.GraphQuotient
    (fun a b : {x : _ & sig_seq B x} =>
     {x
     : {x : {x : _ & sig_seq B x} &
       {j : Graph.graph0 sequence_graph &
       Graph.graph1 sequence_graph x.1 j}} &
     (((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        => t.1) x = a) *
      ((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        =>
        ((t.2).1;
        ((sig_seq B) _f (t.2).2) (t.1).2)) x = b))%type})
& G o seq_colim_sum_to_sum_seq_colim B == idmap}
IsEquiv (seq_colim_sum_to_sum_seq_colim B) srapply (isequiv_adjointify _ L.1 _ L.2); srapply seq_colimit_sum_uniq.
H: Univalence
A: Sequence
B: FibSequence A
L: {G
: {x : _ & fib_seq_to_type_fam B x} ->
  GraphQuotient.GraphQuotient.GraphQuotient
    (fun a b : {x : _ & sig_seq B x} =>
     {x
     : {x : {x : _ & sig_seq B x} &
       {j : Graph.graph0 sequence_graph &
       Graph.graph1 sequence_graph x.1 j}} &
     (((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        => t.1) x = a) *
      ((fun
          t : {x0 : {x : _ & sig_seq B x} &
              {j : Graph.graph0 sequence_graph &
              Graph.graph1 sequence_graph x0.1 j}}
        =>
        ((t.2).1;
        ((sig_seq B) _f (t.2).2) (t.1).2)) x = b))%type})
& G o seq_colim_sum_to_sum_seq_colim B == idmap}
(fun x : {x : _ & fib_seq_to_type_fam B x} =>
 seq_colim_sum_to_sum_seq_colim B (L.1 x))
o seq_colim_sum_to_sum_seq_colim B ==
idmap o seq_colim_sum_to_sum_seq_colim B
    intro x; rewrite L.2; reflexivity.
Defined.

Definition equiv_seq_colim_sum_to_sum_seq_colim `{Univalence} {A} (B : FibSequence A)
  : Colimit (sig_seq B) <~> sig (fib_seq_to_type_fam B)
  := Build_Equiv _ _ _ (isequiv_seq_colim_sum_to_sum_seq_colim B).

(** The canonical map from the sequential colimit of Sigmas to the Sigma of sequential colimits commutes with the first projection; Theorem 5.1. *)
Definition seq_colim_sum_to_sum_seq_colim_fst `{Univalence} {A} (B : FibSequence A)
  : pr1 o (seq_colim_sum_to_sum_seq_colim B) == seq_colim_sum_to_seq_colim_fst B.
H: Univalence
A: Sequence
B: FibSequence A
pr1 o seq_colim_sum_to_sum_seq_colim B ==
seq_colim_sum_to_seq_colim_fst B
Proof.
H: Univalence
A: Sequence
B: FibSequence A
pr1 o seq_colim_sum_to_sum_seq_colim B ==
seq_colim_sum_to_seq_colim_fst B
  srapply seq_colimit_uniq.
H: Univalence
A: Sequence
B: FibSequence A
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (sig_seq B) =>
 (seq_colim_sum_to_sum_seq_colim B x).1)
o inj (sig_seq B) n ==
seq_colim_sum_to_seq_colim_fst B o inj (sig_seq B) n
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph)
(a : sig_seq B n),
ap
  (fun x : Colimit (sig_seq B) =>
   (seq_colim_sum_to_sum_seq_colim B x).1)
  (glue (sig_seq B) n a) @ ?h n a =
?h n.+1 a ^+ @
ap (seq_colim_sum_to_seq_colim_fst B)
  (glue (sig_seq B) n a)
  -
H: Univalence
A: Sequence
B: FibSequence A
forall n : Graph.graph0 sequence_graph,
(fun x : Colimit (sig_seq B) =>
 (seq_colim_sum_to_sum_seq_colim B x).1)
o inj (sig_seq B) n ==
seq_colim_sum_to_seq_colim_fst B o inj (sig_seq B) n exact (fun n a => idpath).
  -
H: Univalence
A: Sequence
B: FibSequence A
forall (n : Graph.graph0 sequence_graph)
(a : sig_seq B n),
ap
  (fun x : Colimit (sig_seq B) =>
   (seq_colim_sum_to_sum_seq_colim B x).1)
  (glue (sig_seq B) n a) @
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : sig_seq B n0) => 1) n a =
(fun (n0 : Graph.graph0 sequence_graph)
   (a0 : sig_seq B n0) => 1) n.+1 a ^+ @
ap (seq_colim_sum_to_seq_colim_fst B)
  (glue (sig_seq B) n a) intros n [a b]; rewrite concat_1p, concat_p1, ap_compose, !Colimit_rec_beta_colimp.
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
ap pr1
  (legs_comm
     {|
       legs :=
         fun (n : Graph.graph0 sequence_graph)
           (X : sig_seq B n) =>
         (inj A n X.1;
         inj (fib_seq_to_seq B (n; X.1)) 0 X.2);
       legs_comm :=
         fun (n m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n m)
           (x : sig_seq B n) =>
         match
           p as p0 in (_ = n0)
           return
             ((inj A n0
                 (((sig_seq B) _f p0) (x.1; x.2)).1;
              inj
                (fib_seq_to_seq B
                   (n0;
                   (((sig_seq B) _f p0) (x.1; x.2)).1))
                0 (((sig_seq B) _f p0) (x.1; x.2)).2) =
              (inj A n x.1;
              inj (fib_seq_to_seq B (n; x.1)) 0 x.2))
         with
         | 1 =>
             Delta (colimp n n.+1 1 x.1)
               (fib_seq_to_type_fam_beta_glue B n x.1)
               (inj
                  (fib_seq_to_seq B
                     (n.+1; ((x.1; x.2) ^+).1)) 0
                  ((x.1; x.2) ^+).2) @
             ap
               (exist (fib_seq_to_type_fam B)
                  (inj A n x.1)) (colimp 0 1 1 x.2)
         end
     |} n n.+1 1 (a; b)) =
legs_comm
  {|
    legs :=
      fun (n : Graph.graph0 sequence_graph)
        (X : sig_seq B n) => inj A n X.1;
    legs_comm :=
      fun (n m : Graph.graph0 sequence_graph)
        (p : Graph.graph1 sequence_graph n m)
        (x : sig_seq B n) =>
      match
        p as p0 in (_ = n0)
        return
          (inj A n0 (((sig_seq B) _f p0) (x.1; x.2)).1 =
           inj A n x.1)
      with
      | 1 => colimp n n.+1 1 x.1
      end
  |} n n.+1 1 (a; b)
    rewrite ap_pp, (Delta_proj _ (fib_seq_to_type_fam_beta_glue B n a)).
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
colimp n n.+1 1 a @
ap pr1
  (ap (exist (fib_seq_to_type_fam B) (inj A n a))
     (colimp 0 1 1 b)) =
legs_comm
  {|
    legs :=
      fun (n : Graph.graph0 sequence_graph)
        (X : sig_seq B n) => inj A n X.1;
    legs_comm :=
      fun (n m : Graph.graph0 sequence_graph)
        (p : Graph.graph1 sequence_graph n m)
        (x : sig_seq B n) =>
      match
        p as p0 in (_ = n0)
        return
          (inj A n0 (((sig_seq B) _f p0) (x.1; x.2)).1 =
           inj A n x.1)
      with
      | 1 => colimp n n.+1 1 x.1
      end
  |} n n.+1 1 (a; b)
    srapply (whiskerL _ _ @ concat_p1 _); rewrite (ap_compose _ _ _)^; simpl.
H: Univalence
A: Sequence
B: FibSequence A
n: Graph.graph0 sequence_graph
a: A n
b: B (n; a)
ap
  (fun _ : Colimit (fib_seq_to_seq B (n; a)) =>
   inj A n a) (colimp 0 1 1 b) = 1
    rewrite ap_const; reflexivity.
Defined.

(** The characterization of path spaces in sequential colimits; Theorem 7.4, first part. *)
Definition path_seq (A : Sequence) (a1 a2 : A 0)
  := Build_Sequence (fun k => a1^+k = a2^+k) (fun k p => ap (fun a => a^+) p).

Definition equiv_path_colim_zero `{Univalence} {A : Sequence} (a1 a2 : A 0) :
  (inj A 0 a1 = inj A 0 a2) <~> Colimit (path_seq A a1 a2).
H: Univalence
A: Sequence
a1, a2: A 0
inj A 0 a1 = inj A 0 a2 <~> Colimit (path_seq A a1 a2) 
Proof.
H: Univalence
A: Sequence
a1, a2: A 0
inj A 0 a1 = inj A 0 a2 <~> Colimit (path_seq A a1 a2)
  pose (B := Build_FibSequence A (fun x => a1^+(x.1) = x.2) (fun x => ap (fun a => a^+))).
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
inj A 0 a1 = inj A 0 a2 <~> Colimit (path_seq A a1 a2)
  transitivity (fib_seq_to_type_fam B (inj A 0 a2)).
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
inj A 0 a1 = inj A 0 a2 <~>
fib_seq_to_type_fam B (inj A 0 a2)
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
fib_seq_to_type_fam B (inj A 0 a2) <~>
Colimit (path_seq A a1 a2)
  +
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
inj A 0 a1 = inj A 0 a2 <~>
fib_seq_to_type_fam B (inj A 0 a2) symmetry; srapply equiv_path_from_contr.
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
fib_seq_to_type_fam B (inj A 0 a1)
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
Contr {y : Colimit A & fib_seq_to_type_fam B y}
    -
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
fib_seq_to_type_fam B (inj A 0 a1) exact (inj (fib_seq_to_seq B (0;a1)) 0 idpath).
    -
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
Contr {y : Colimit A & fib_seq_to_type_fam B y} srefine (contr_equiv _ (seq_colim_sum_to_sum_seq_colim B)).
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
Contr (Colimit (sig_seq B))
      srapply contr_colim_contr_seq; intro k; srapply contr_basedpaths.
  +
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
fib_seq_to_type_fam B (inj A 0 a2) <~>
Colimit (path_seq A a1 a2) srapply equiv_functor_colimit; srefine (transitivity (equiv_fib_seq_to_seq B (0;a2)) _).
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
fib_seq_to_seq' B (0; a2) ~d~ path_seq A a1 a2
    srapply Build_diagram_equiv.
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
DiagramMap (fib_seq_to_seq' B (0; a2))
  (path_seq A a1 a2)
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall i : Graph.graph0 sequence_graph, IsEquiv (?m i)
    *
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
DiagramMap (fib_seq_to_seq' B (0; a2))
  (path_seq A a1 a2) srapply Build_DiagramMap.
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall i : Graph.graph0 sequence_graph,
fib_seq_to_seq' B (0; a2) i -> path_seq A a1 a2 i
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq' B (0; a2) i),
((path_seq A a1 a2) _f g) (?DiagramMap_obj i x) =
?DiagramMap_obj j
  (((fib_seq_to_seq' B (0; a2)) _f g) x)
      -
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall i : Graph.graph0 sequence_graph,
fib_seq_to_seq' B (0; a2) i -> path_seq A a1 a2 i exact (fun n => coe (ap B (seq_shift_pair_from_zero a2 n))).
      -
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j)
(x : fib_seq_to_seq' B (0; a2) i),
((path_seq A a1 a2) _f g)
  ((fun n : Graph.graph0 sequence_graph =>
    coe (ap B (seq_shift_pair_from_zero a2 n))) i x) =
(fun n : Graph.graph0 sequence_graph =>
 coe (ap B (seq_shift_pair_from_zero a2 n))) j
  (((fib_seq_to_seq' B (0; a2)) _f g) x) intros n m p b; destruct p; srapply (K _ _ (seq_shift_pair_from_zero a2 n)).
    *
H: Univalence
A: Sequence
a1, a2: A 0
B:= {|
  fibSequence :=
    fun x : {x : _ & A x} => a1 ^+ (x.1) = x.2;
  fibSequenceArr :=
    fun x : {x : _ & A x} =>
    ap (fun a : A x.1 => a ^+)
|}: FibSequence A
forall i : Graph.graph0 sequence_graph,
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n : Graph.graph0 sequence_graph =>
       coe (ap B (seq_shift_pair_from_zero a2 n));
     DiagramMap_comm :=
       fun (n m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n m)
         (b : fib_seq_to_seq' B (0; a2) n) =>
       match
         p as p0 in (_ = n0)
         return
           (((path_seq A a1 a2) _f p0)
              (equiv_path (B (0; a2) ^++ n)
                 (B (n; a2 ^+ n))
                 (ap B (seq_shift_pair_from_zero a2 n))
                 b) =
            equiv_path (B (0; a2) ^++ n0)
              (B (n0; a2 ^+ n0))
              (ap B (seq_shift_pair_from_zero a2 n0))
              (((fib_seq_to_seq' B (0; a2)) _f p0) b))
       with
       | 1 =>
           K seq_pair_shift (fibSequenceArr B)
             (seq_shift_pair_from_zero a2 n)
       end
   |} i) exact _.
Defined.

(** The characterization of path spaces in sequential colimits; Theorem 7.4, second part. *)
Definition equiv_path_colim `{Univalence} {A : Sequence} n (a1 a2 : A n) :
  (inj A n a1 = inj A n a2) <~> Colimit (path_seq (shift_seq A n) a1 a2).
H: Univalence
A: Sequence
n: Graph.graph0 sequence_graph
a1, a2: A n
inj A n a1 = inj A n a2 <~>
Colimit (path_seq (shift_seq A n) a1 a2)
Proof.
H: Univalence
A: Sequence
n: Graph.graph0 sequence_graph
a1, a2: A n
inj A n a1 = inj A n a2 <~>
Colimit (path_seq (shift_seq A n) a1 a2)
  srefine (transitivity _ (equiv_path_colim_zero _ _)); symmetry.
H: Univalence
A: Sequence
n: Graph.graph0 sequence_graph
a1, a2: A n
inj (shift_seq A n) 0 a1 = inj (shift_seq A n) 0 a2 <~>
inj A n a1 = inj A n a2
  srapply (@equiv_ap _ _ (colim_shift_seq_to_colim_seq A n)).
Defined.

Open Scope trunc_scope.

(** Corollary 7.7.1, second part. *)
Instance trunc_seq_colim `{Univalence} {A : Sequence} k :
  (forall n, IsTrunc k (A n)) -> IsTrunc k (Colimit A) | 100.
H: Univalence
A: Sequence
k: trunc_index
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k (A n)) -> IsTrunc k (Colimit A)
Proof.
H: Univalence
A: Sequence
k: trunc_index
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k (A n)) -> IsTrunc k (Colimit A)
  revert A; induction k as [ | k IHk].
H: Univalence
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, Contr (A n)) ->
Contr (Colimit A)
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) -> IsTrunc k.+1 (Colimit A)
  -
H: Univalence
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, Contr (A n)) ->
Contr (Colimit A) exact contr_colim_contr_seq.
  -
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) -> IsTrunc k.+1 (Colimit A) intros A trH; apply istrunc_S; srapply Colimit_ind.
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
forall (i : Graph.graph0 sequence_graph) (x : A i),
(fun w : Colimit A =>
 forall y : Colimit A, IsTrunc k (w = y)) (inj A i x)
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
transport
  (fun w : Colimit A =>
   forall y : Colimit A, IsTrunc k (w = y))
  (colimp i j g x) (?q j ((A _f g) x)) = ?q i x
    +
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
forall (i : Graph.graph0 sequence_graph) (x : A i),
(fun w : Colimit A =>
 forall y : Colimit A, IsTrunc k (w = y)) (inj A i x) intro n; revert trH; revert A; induction n as [ | n IHn].
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (x : A 0%nat) (y : Colimit A),
IsTrunc k (inj A 0%nat x = y)
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
n: nat
IHn: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (x : A n) (y : Colimit A), IsTrunc k (inj A n x = y)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (x : A n.+1%nat) (y : Colimit A),
IsTrunc k (inj A n.+1%nat x = y)
      *
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (x : A 0%nat) (y : Colimit A),
IsTrunc k (inj A 0%nat x = y) intros A trH a; srapply Colimit_ind.
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
forall (i : Graph.graph0 sequence_graph) (x : A i),
(fun w : Colimit A => IsTrunc k (inj A 0%nat a = w))
  (inj A i x)
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
transport
  (fun w : Colimit A => IsTrunc k (inj A 0%nat a = w))
  (colimp i j g x) (?q j ((A _f g) x)) = ?q i x
        {
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
forall (i : Graph.graph0 sequence_graph) (x : A i),
(fun w : Colimit A => IsTrunc k (inj A 0%nat a = w))
  (inj A i x) intros m b; revert b; revert a; revert trH; revert A; induction m as [ | m IHm].
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall a b : A 0%nat,
IsTrunc k (inj A 0%nat a = inj A 0%nat b)
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m.+1%nat),
IsTrunc k (inj A 0%nat a = inj A m.+1%nat b)
          {
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall a b : A 0%nat,
IsTrunc k (inj A 0%nat a = inj A 0%nat b) intros A trH a b.
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a, b: A 0%nat
IsTrunc k (inj A 0%nat a = inj A 0%nat b)
            exact (istrunc_equiv_istrunc _ (equiv_inverse (equiv_path_colim _ a b))). }
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m.+1%nat),
IsTrunc k (inj A 0%nat a = inj A m.+1%nat b)
          {
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m.+1%nat),
IsTrunc k (inj A 0%nat a = inj A m.+1%nat b) intros A trH a b.
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
b: A m.+1%nat
IsTrunc k (inj A 0%nat a = inj A m.+1%nat b)
            srefine (istrunc_equiv_istrunc _ (equiv_inverse (equiv_concat_l (glue A _ a) _))).
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
b: A m.+1%nat
IsTrunc k (inj A 1%nat a ^+ = inj A m.+1%nat b)
            srapply (@istrunc_equiv_istrunc _ _ _ k (IHm (succ_seq A) _ (@arr _ A 0%nat _ 1%path a) b)).
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
m: nat
IHm: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (a : A 0%nat) (b : A m), IsTrunc k (inj A 0%nat a = inj A m b)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
b: A m.+1%nat
inj (succ_seq A) 0%nat a ^+ = inj (succ_seq A) m b <~>
inj A 1%nat a ^+ = inj A m.+1%nat b
            srapply (equiv_ap (colim_succ_seq_to_colim_seq A)). }}
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
transport
  (fun w : Colimit A => IsTrunc k (inj A 0%nat a = w))
  (colimp i j g x)
  ((fun (m : Graph.graph0 sequence_graph) (b : A m) =>
    nat_rect
      (fun m0 : nat =>
       forall A : Sequence,
       (forall n : Graph.graph0 sequence_graph,
        IsTrunc k.+1 (A n)) ->
       forall (a : A 0%nat) (b0 : A m0),
       IsTrunc k (inj A 0%nat a = inj A m0 b0))
      (fun (A : Sequence)
         (trH : forall
                n : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n)) (a b0 : A 0%nat)
       =>
       istrunc_equiv_istrunc
         (Colimit (path_seq (shift_seq A 0) a b0))
         (equiv_path_colim 0%nat a b0)^-1)
      (fun (m0 : nat)
         (IHm : forall A : Sequence,
                (forall
                 n : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A n)) ->
                forall (a : A 0%nat) (b0 : A m0),
                IsTrunc k
                  (inj A 0%nat a = inj A m0 b0))
         (A : Sequence)
         (trH : forall
                n : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n)) (a : A 0%nat)
         (b0 : A m0.+1%nat) =>
       istrunc_equiv_istrunc
         (inj A 1%nat a ^+ = inj A m0.+1%nat b0)
         (equiv_concat_l (glue A 0%nat a)
            (inj A m0.+1%nat b0))^-1) m A trH a b) j
     ((A _f g) x)) =
(fun (m : Graph.graph0 sequence_graph) (b : A m) =>
 nat_rect
   (fun m0 : nat =>
    forall A : Sequence,
    (forall n : Graph.graph0 sequence_graph,
     IsTrunc k.+1 (A n)) ->
    forall (a : A 0%nat) (b0 : A m0),
    IsTrunc k (inj A 0%nat a = inj A m0 b0))
   (fun (A : Sequence)
      (trH : forall n : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n)) (a b0 : A 0%nat) =>
    istrunc_equiv_istrunc
      (Colimit (path_seq (shift_seq A 0) a b0))
      (equiv_path_colim 0%nat a b0)^-1)
   (fun (m0 : nat)
      (IHm : forall A : Sequence,
             (forall n : Graph.graph0 sequence_graph,
              IsTrunc k.+1 (A n)) ->
             forall (a : A 0%nat) (b0 : A m0),
             IsTrunc k (inj A 0%nat a = inj A m0 b0))
      (A : Sequence)
      (trH : forall n : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n)) (a : A 0%nat)
      (b0 : A m0.+1%nat) =>
    istrunc_equiv_istrunc
      (inj A 1%nat a ^+ = inj A m0.+1%nat b0)
      (equiv_concat_l (glue A 0%nat a)
         (inj A m0.+1%nat b0))^-1) m A trH a b) i x
        {
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A 0%nat
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
transport
  (fun w : Colimit A => IsTrunc k (inj A 0%nat a = w))
  (colimp i j g x)
  ((fun (m : Graph.graph0 sequence_graph) (b : A m) =>
    nat_rect
      (fun m0 : nat =>
       forall A : Sequence,
       (forall n : Graph.graph0 sequence_graph,
        IsTrunc k.+1 (A n)) ->
       forall (a : A 0%nat) (b0 : A m0),
       IsTrunc k (inj A 0%nat a = inj A m0 b0))
      (fun (A : Sequence)
         (trH : forall
                n : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n)) (a b0 : A 0%nat)
       =>
       istrunc_equiv_istrunc
         (Colimit (path_seq (shift_seq A 0) a b0))
         (equiv_path_colim 0%nat a b0)^-1)
      (fun (m0 : nat)
         (IHm : forall A : Sequence,
                (forall
                 n : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A n)) ->
                forall (a : A 0%nat) (b0 : A m0),
                IsTrunc k
                  (inj A 0%nat a = inj A m0 b0))
         (A : Sequence)
         (trH : forall
                n : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n)) (a : A 0%nat)
         (b0 : A m0.+1%nat) =>
       istrunc_equiv_istrunc
         (inj A 1%nat a ^+ = inj A m0.+1%nat b0)
         (equiv_concat_l (glue A 0%nat a)
            (inj A m0.+1%nat b0))^-1) m A trH a b) j
     ((A _f g) x)) =
(fun (m : Graph.graph0 sequence_graph) (b : A m) =>
 nat_rect
   (fun m0 : nat =>
    forall A : Sequence,
    (forall n : Graph.graph0 sequence_graph,
     IsTrunc k.+1 (A n)) ->
    forall (a : A 0%nat) (b0 : A m0),
    IsTrunc k (inj A 0%nat a = inj A m0 b0))
   (fun (A : Sequence)
      (trH : forall n : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n)) (a b0 : A 0%nat) =>
    istrunc_equiv_istrunc
      (Colimit (path_seq (shift_seq A 0) a b0))
      (equiv_path_colim 0%nat a b0)^-1)
   (fun (m0 : nat)
      (IHm : forall A : Sequence,
             (forall n : Graph.graph0 sequence_graph,
              IsTrunc k.+1 (A n)) ->
             forall (a : A 0%nat) (b0 : A m0),
             IsTrunc k (inj A 0%nat a = inj A m0 b0))
      (A : Sequence)
      (trH : forall n : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n)) (a : A 0%nat)
      (b0 : A m0.+1%nat) =>
    istrunc_equiv_istrunc
      (inj A 1%nat a ^+ = inj A m0.+1%nat b0)
      (equiv_concat_l (glue A 0%nat a)
         (inj A m0.+1%nat b0))^-1) m A trH a b) i x intros n m p b; snapply path_ishprop; snapply ishprop_istrunc; exact _. }
      *
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
n: nat
IHn: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (x : A n) (y : Colimit A), IsTrunc k (inj A n x = y)
forall A : Sequence,
(forall n : Graph.graph0 sequence_graph,
 IsTrunc k.+1 (A n)) ->
forall (x : A n.+1%nat) (y : Colimit A),
IsTrunc k (inj A n.+1%nat x = y) intros A trH a; srapply (functor_forall_equiv_pb (colim_succ_seq_to_colim_seq A)).
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
n: nat
IHn: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)) ->
forall (x : A n) (y : Colimit A), IsTrunc k (inj A n x = y)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
a: A n.+1%nat
forall a0 : Colimit (succ_seq A),
(fun b : Colimit A => IsTrunc k (inj A n.+1%nat a = b))
  (colim_succ_seq_to_colim_seq A a0)
        intro x; srapply (@istrunc_equiv_istrunc _ _ _ k (IHn (succ_seq A) _ a x)); srapply equiv_ap.
    +
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
forall (i j : Graph.graph0 sequence_graph)
(g : Graph.graph1 sequence_graph i j) (x : A i),
transport
  (fun w : Colimit A =>
   forall y : Colimit A, IsTrunc k (w = y))
  (colimp i j g x)
  ((fun n : Graph.graph0 sequence_graph =>
    nat_rect
      (fun n0 : nat =>
       forall A : Sequence,
       (forall n1 : Graph.graph0 sequence_graph,
        IsTrunc k.+1 (A n1)) ->
       forall (x0 : A n0) (y : Colimit A),
       IsTrunc k (inj A n0 x0 = y))
      (fun (A : Sequence)
         (trH : forall
                n0 : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n0)) (a : A 0%nat) =>
       Colimit_ind
         (fun w : Colimit A =>
          IsTrunc k (inj A 0%nat a = w))
         (fun (m : Graph.graph0 sequence_graph)
            (b : A m) =>
          nat_rect
            (fun m0 : nat =>
             forall A0 : Sequence,
             (forall n0 : Graph.graph0 sequence_graph,
              IsTrunc k.+1 (A0 n0)) ->
             forall (a0 : A0 0%nat) (b0 : A0 m0),
             IsTrunc k
               (inj A0 0%nat a0 = inj A0 m0 b0))
            (fun (A0 : Sequence)
               (trH0 : forall
                       n0 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n0))
               (a0 b0 : A0 0%nat) =>
             istrunc_equiv_istrunc
               (Colimit
                  (path_seq (shift_seq A0 0) a0 b0))
               (equiv_path_colim 0%nat a0 b0)^-1)
            (fun (m0 : nat)
               (IHm : forall A0 : Sequence,
                      (forall
                       n0 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n0)) ->
                      forall (a0 : A0 0%nat)
                      (b0 : A0 m0),
                      IsTrunc k
                        (inj A0 0%nat a0 =
                         inj A0 m0 b0))
               (A0 : Sequence)
               (trH0 : forall
                       n0 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n0))
               (a0 : A0 0%nat) (b0 : A0 m0.+1%nat) =>
             istrunc_equiv_istrunc
               (inj A0 1%nat a0 ^+ =
                inj A0 m0.+1%nat b0)
               (equiv_concat_l (glue A0 0%nat a0)
                  (inj A0 m0.+1%nat b0))^-1) m A trH a
            b)
         (fun (n0 m : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph n0 m)
            (b : A n0) =>
          path_ishprop
            (transport
               (fun w : Colimit A =>
                IsTrunc k (inj A 0%nat a = w))
               (colimp n0 m p b)
               ((fun
                   (m0 : Graph.graph0 sequence_graph)
                   (b0 : A m0) =>
                 nat_rect
                   (fun m1 : nat =>
                    forall A0 : Sequence,
                    (forall ..., ...) ->
                    forall (a0 : ...) (b1 : ...),
                    IsTrunc k ...)
                   (fun (A0 : Sequence)
                      (trH0 : forall n1 : ...,
                              IsTrunc k.+1 ...)
                      (a0 b1 : A0 0%nat) =>
                    istrunc_equiv_istrunc
                      (Colimit (...))
                      (equiv_path_colim 0%nat a0 b1)^-1)
                   (fun (m1 : nat)
                      (IHm : forall A0 : Sequence,
                             ... -> ...)
                      (A0 : Sequence)
                      (trH0 : forall n1 : ...,
                              IsTrunc k.+1 ...)
                      (a0 : A0 0%nat)
                      (b1 : A0 m1.+1%nat) =>
                    istrunc_equiv_istrunc
                      (inj A0 1%nat ... =
                       inj A0 m1.+1%nat b1)
                      (equiv_concat_l (...) (...))^-1)
                   m0 A trH a b0) m ((A _f p) b)))
            (nat_rect
               (fun m0 : nat =>
                forall A0 : Sequence,
                (forall
                 n1 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A0 n1)) ->
                forall (a0 : A0 0%nat) (b0 : A0 m0),
                IsTrunc k
                  (inj A0 0%nat a0 = inj A0 m0 b0))
               (fun (A0 : Sequence)
                  (trH0 : forall
                          n1 : Graph.graph0
                                 sequence_graph,
                          IsTrunc k.+1 (A0 n1))
                  (a0 b0 : A0 0%nat) =>
                istrunc_equiv_istrunc
                  (Colimit
                     (path_seq (shift_seq A0 0) a0 b0))
                  (equiv_path_colim 0%nat a0 b0)^-1)
               (fun (m0 : nat)
                  (IHm : forall A0 : Sequence,
                         (forall
                          n1 : Graph.graph0
                                 sequence_graph,
                          IsTrunc k.+1 (A0 n1)) ->
                         forall (a0 : A0 0%nat)
                         (b0 : A0 m0),
                         IsTrunc k
                           (inj A0 0%nat a0 =
                            inj A0 m0 b0))
                  (A0 : Sequence)
                  (trH0 : forall
                          n1 : Graph.graph0
                                 sequence_graph,
                          IsTrunc k.+1 (A0 n1))
                  (a0 : A0 0%nat) (b0 : A0 m0.+1%nat)
                =>
                istrunc_equiv_istrunc
                  (inj A0 1%nat a0 ^+ =
                   inj A0 m0.+1%nat b0)
                  (equiv_concat_l (glue A0 0%nat a0)
                     (inj A0 m0.+1%nat b0))^-1) n0 A
               trH a b)))
      (fun (n0 : nat)
         (IHn : forall A : Sequence,
                (forall
                 n1 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A n1)) ->
                forall (x0 : A n0) (y : Colimit A),
                IsTrunc k (inj A n0 x0 = y))
         (A : Sequence)
         (trH : forall
                n1 : Graph.graph0 sequence_graph,
                IsTrunc k.+1 (A n1)) (a : A n0.+1%nat)
       =>
       functor_forall_equiv_pb
         (colim_succ_seq_to_colim_seq A)
         (fun x0 : Colimit (succ_seq A) =>
          istrunc_equiv_istrunc
            (inj (succ_seq A) n0 a = x0)
            (equiv_ap (colim_succ_seq_to_colim_seq A)
               (inj (succ_seq A) n0 a) x0))) n A trH)
     j ((A _f g) x)) =
(fun n : Graph.graph0 sequence_graph =>
 nat_rect
   (fun n0 : nat =>
    forall A : Sequence,
    (forall n1 : Graph.graph0 sequence_graph,
     IsTrunc k.+1 (A n1)) ->
    forall (x0 : A n0) (y : Colimit A),
    IsTrunc k (inj A n0 x0 = y))
   (fun (A : Sequence)
      (trH : forall n0 : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n0)) (a : A 0%nat) =>
    Colimit_ind
      (fun w : Colimit A =>
       IsTrunc k (inj A 0%nat a = w))
      (fun (m : Graph.graph0 sequence_graph) (b : A m)
       =>
       nat_rect
         (fun m0 : nat =>
          forall A0 : Sequence,
          (forall n0 : Graph.graph0 sequence_graph,
           IsTrunc k.+1 (A0 n0)) ->
          forall (a0 : A0 0%nat) (b0 : A0 m0),
          IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
         (fun (A0 : Sequence)
            (trH0 : forall
                    n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A0 n0))
            (a0 b0 : A0 0%nat) =>
          istrunc_equiv_istrunc
            (Colimit (path_seq (shift_seq A0 0) a0 b0))
            (equiv_path_colim 0%nat a0 b0)^-1)
         (fun (m0 : nat)
            (IHm : forall A0 : Sequence,
                   (forall
                    n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A0 n0)) ->
                   forall (a0 : A0 0%nat)
                   (b0 : A0 m0),
                   IsTrunc k
                     (inj A0 0%nat a0 = inj A0 m0 b0))
            (A0 : Sequence)
            (trH0 : forall
                    n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A0 n0))
            (a0 : A0 0%nat) (b0 : A0 m0.+1%nat) =>
          istrunc_equiv_istrunc
            (inj A0 1%nat a0 ^+ = inj A0 m0.+1%nat b0)
            (equiv_concat_l (glue A0 0%nat a0)
               (inj A0 m0.+1%nat b0))^-1) m A trH a b)
      (fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m)
         (b : A n0) =>
       path_ishprop
         (transport
            (fun w : Colimit A =>
             IsTrunc k (inj A 0%nat a = w))
            (colimp n0 m p b)
            ((fun (m0 : Graph.graph0 sequence_graph)
                (b0 : A m0) =>
              nat_rect
                (fun m1 : nat =>
                 forall A0 : Sequence,
                 (forall
                  n1 : Graph.graph0 sequence_graph,
                  IsTrunc k.+1 (...)) ->
                 forall (a0 : A0 0%nat) (b1 : A0 m1),
                 IsTrunc k (... = ...))
                (fun (A0 : Sequence)
                   (trH0 : forall
                           n1 : Graph.graph0
                                  sequence_graph,
                           IsTrunc k.+1 (A0 n1))
                   (a0 b1 : A0 0%nat) =>
                 istrunc_equiv_istrunc
                   (Colimit (path_seq (...) a0 b1))
                   (equiv_path_colim 0%nat a0 b1)^-1)
                (fun (m1 : nat)
                   (IHm : forall A0 : Sequence,
                          (forall ..., ...) ->
                          forall (a0 : ...)
                          (b1 : ...), IsTrunc k ...)
                   (A0 : Sequence)
                   (trH0 : forall
                           n1 : Graph.graph0
                                  sequence_graph,
                           IsTrunc k.+1 (A0 n1))
                   (a0 : A0 0%nat) (b1 : A0 m1.+1%nat)
                 =>
                 istrunc_equiv_istrunc
                   (inj A0 1%nat a0 ^+ =
                    inj A0 m1.+1%nat b1)
                   (equiv_concat_l (glue A0 0%nat a0)
                      (inj A0 m1.+1%nat b1))^-1) m0 A
                trH a b0) m ((A _f p) b)))
         (nat_rect
            (fun m0 : nat =>
             forall A0 : Sequence,
             (forall n1 : Graph.graph0 sequence_graph,
              IsTrunc k.+1 (A0 n1)) ->
             forall (a0 : A0 0%nat) (b0 : A0 m0),
             IsTrunc k
               (inj A0 0%nat a0 = inj A0 m0 b0))
            (fun (A0 : Sequence)
               (trH0 : forall
                       n1 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n1))
               (a0 b0 : A0 0%nat) =>
             istrunc_equiv_istrunc
               (Colimit
                  (path_seq (shift_seq A0 0) a0 b0))
               (equiv_path_colim 0%nat a0 b0)^-1)
            (fun (m0 : nat)
               (IHm : forall A0 : Sequence,
                      (forall
                       n1 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n1)) ->
                      forall (a0 : A0 0%nat)
                      (b0 : A0 m0),
                      IsTrunc k
                        (inj A0 0%nat a0 =
                         inj A0 m0 b0))
               (A0 : Sequence)
               (trH0 : forall
                       n1 : Graph.graph0
                              sequence_graph,
                       IsTrunc k.+1 (A0 n1))
               (a0 : A0 0%nat) (b0 : A0 m0.+1%nat) =>
             istrunc_equiv_istrunc
               (inj A0 1%nat a0 ^+ =
                inj A0 m0.+1%nat b0)
               (equiv_concat_l (glue A0 0%nat a0)
                  (inj A0 m0.+1%nat b0))^-1) n0 A trH
            a b)))
   (fun (n0 : nat)
      (IHn : forall A : Sequence,
             (forall n1 : Graph.graph0 sequence_graph,
              IsTrunc k.+1 (A n1)) ->
             forall (x0 : A n0) (y : Colimit A),
             IsTrunc k (inj A n0 x0 = y))
      (A : Sequence)
      (trH : forall n1 : Graph.graph0 sequence_graph,
             IsTrunc k.+1 (A n1)) (a : A n0.+1%nat) =>
    functor_forall_equiv_pb
      (colim_succ_seq_to_colim_seq A)
      (fun x0 : Colimit (succ_seq A) =>
       istrunc_equiv_istrunc
         (inj (succ_seq A) n0 a = x0)
         (equiv_ap (colim_succ_seq_to_colim_seq A)
            (inj (succ_seq A) n0 a) x0))) n A trH) i x intros n m p a; snapply path_ishprop; snapply istrunc_forall.
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A n)) ->
IsTrunc k (Colimit A)
A: Sequence
trH: forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n)
n, m: Graph.graph0 sequence_graph
p: Graph.graph1 sequence_graph n m
a: A n
forall a0 : Colimit A,
IsHProp
  ((fun a1 : Colimit A => IsTrunc k (inj A n a = a1))
     a0)
      intro x; srapply ishprop_istrunc.
Defined.