(** * 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. *)

From HoTT Require Import Basics.
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) <~>
{H0 : 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 => H0 j ((A _f g) x)) == H0 i}
  symmetry.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
{H0 : 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 => H0 j ((A _f g) x)) == H0 i} <~>
(forall n : Graph.graph0 sequence_graph, A n -> P)
  srapply Build_Equiv.
H: Funext
A: Sequence
P: Type
IsHProp0: IsHProp P
{H0 : 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 => H0 j ((A _f g) x)) == H0 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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 x0 : B i, colim 1 (a 1) = colim i x0
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 x0 : B i, colim 1 (a 1) = colim i x0
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 x0 : B i, colim 1 (a 1) = colim i x0
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 x0 : B i, colim 1 (a 1) = colim i x0
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 x0 : B i, colim 1 (a 1) = colim i x0
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 n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 x0 : B i, colim 1 (a 1) = colim i x0)
     (fun x0 : B 0 => colimp 0 1 1 x0)
     (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
        (x0 : 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 x0)))
     n.+1 x ^+) =
nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
  (fun x0 : B 0 => colimp 0 1 1 x0)
  (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
     (x0 : 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 x0)))
  n x
  rewrite transport_paths_FlFr.
funext: Funext
A: Sequence
a: forall n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+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 x0 : B i, colim 1 (a 1) = colim i x0)
   (fun x0 : B 0 => colimp 0 1 1 x0)
   (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
      (x0 : 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 x0)))
   n.+1 x ^+) @
ap idmap (colimp n n.+1 1 x) =
nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
  (fun x0 : B 0 => colimp 0 1 1 x0)
  (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
     (x0 : 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 x0)))
  n x
  rewrite ap_const.
funext: Funext
A: Sequence
a: forall n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
(1^ @
 nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
   (fun x0 : B 0 => colimp 0 1 1 x0)
   (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
      (x0 : 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 x0)))
   n.+1 x ^+) @
ap idmap (colimp n n.+1 1 x) =
nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
  (fun x0 : B 0 => colimp 0 1 1 x0)
  (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
     (x0 : 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 x0)))
  n x
  rewrite ap_idmap.
funext: Funext
A: Sequence
a: forall n0 : Graph.graph0 sequence_graph, A n0
H: forall n0 : nat, const (a n0.+1) == A _f 1
B:= Build_Sequence A (fun n0 : nat => const (a n0.+1)): Sequence
n, m: Graph.graph0 sequence_graph
x: B n
(1^ @
 nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
   (fun x0 : B 0 => colimp 0 1 1 x0)
   (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
      (x0 : 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 x0)))
   n.+1 x ^+) @
colimp n n.+1 1 x =
nat_rect (fun i : nat => forall x0 : B i, colim 1 (a 1) = colim i x0)
  (fun x0 : B 0 => colimp 0 1 1 x0)
  (fun (i : nat) (IHi : forall x0 : B i, colim 1 (a 1) = colim i x0)
     (x0 : 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 x0)))
  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 n0 : Graph.graph0 sequence_graph, F o inj A n0 == G o inj A n0
H: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0),
ap F (glue A n0 a0) @ h n0 a0 = h n0.+1 a0 ^+ @ ap G (glue A n0 a0)
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 n0 : Graph.graph0 sequence_graph, F o inj A n0 == G o inj A n0
H: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0),
ap F (glue A n0 a0) @ h n0 a0 = h n0.+1 a0 ^+ @ ap G (glue A n0 a0)
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 ((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
        |} 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 ((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
        |} 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 (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) 
           (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 => colimp n0 n0.+1 1 a0 ^+
         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 (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) 
           (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 => colimp n0 n0.+1 1 a0 ^+
         end
     |})
  (legs_comm
     {|
       legs :=
         fun (n0 : Graph.graph0 sequence_graph) (a0 : succ_seq A n0) =>
         inj A n0.+1 a0;
       legs_comm :=
         fun (n0 m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n0 m) =>
         match
           p as p0 in (_ = n1)
           return
             ((fun x : succ_seq A n0 => inj A n1.+1 (((succ_seq A) _f p0) x)) ==
              (fun a0 : succ_seq A n0 => inj A n0.+1 a0))
         with
         | 1 => colimp n0.+1 n0.+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) (y0 : Y x), I (F x) (G x y0) = I x y0
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) (y0 : Y x), I (F x) (G x y0) = I x y0
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) (y0 : Y x), I (F x) (G x y0) = I x y0
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) (y0 : Y x), I (F x) (G x y0) = I x y0
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 (A (k0 + 0)) (A k0) 
                     (ap A (nat_add_zero_r k0)) 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 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 (A (k0 + 0)) (A k0) 
                     (ap A (nat_add_zero_r k0)) 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 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 (n0 : nat) (a0 : A n0) => 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 (n0 : nat) (a0 : A n0) => 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 (n1 : nat) (a0 : A n1) => 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 (shift_seq A n)) _f p0)
                       (equiv_path (A (k + n.+1)) 
                          (A (k + n).+1) (ap A (nat_add_succ_r k n)) a0) =
                     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) a0))
                with
                | 1 =>
                    K S (fun (n1 : nat) (a1 : A n1) => 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 (n1 : nat) (a0 : A n1) => 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
                  (((succ_seq (shift_seq A n)) _f p0)
                     (equiv_path (A (k0 + n.+1)) (A (k0 + n).+1)
                        (ap A (nat_add_succ_r k0 n)) a0) =
                   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) a0))
              with
              | 1 =>
                  K S (fun (n1 : nat) (a1 : A n1) => 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
                  (((succ_seq (shift_seq A n)) _f p0)
                     (equiv_path (A (k0 + n.+1)) (A (k0 + n).+1)
                        (ap A (nat_add_succ_r k0 n)) a0) =
                   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) a0))
              with
              | 1 =>
                  K S (fun (n1 : nat) (a1 : A n1) => 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 (shift_seq A n)) _f p0)
                       (equiv_path (A (k + n.+1)) 
                          (A (k + n).+1) (ap A (nat_add_succ_r k n)) a0) =
                     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) a0))
                with
                | 1 =>
                    K S (fun (n1 : nat) (a1 : A n1) => 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
             DiagramMap_comm :=
               fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
               match
                 p as p0 in (_ = n0)
                 return
                   (match
                      p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
                    with
                    | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
                    end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
                    transport idmap (ap A (nat_add_succ_r n0 n))
                      (match
                         p0 in (_ = n1)
                         return (A (k0 + n.+1) -> A (n1 + n.+1))
                       with
                       | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                       end a0))
               with
               | 1 =>
                   K S (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                     (nat_add_succ_r k0 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
              DiagramMap_comm :=
                fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
                match
                  p as p0 in (_ = n0)
                  return
                    (match
                       p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
                     with
                     | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
                     end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
                     transport idmap (ap A (nat_add_succ_r n0 n))
                       (match
                          p0 in (_ = n1)
                          return (A (k0 + n.+1) -> A (n1 + n.+1))
                        with
                        | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                        end a0))
                with
                | 1 =>
                    K S (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                      (nat_add_succ_r k0 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
            DiagramMap_comm :=
              fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
              match
                p as p0 in (_ = n0)
                return
                  (match
                     p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
                   with
                   | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
                   end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
                   transport idmap (ap A (nat_add_succ_r n0 n))
                     (match
                        p0 in (_ = n1)
                        return (A (k0 + n.+1) -> A (n1 + n.+1))
                      with
                      | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                      end a0))
              with
              | 1 =>
                  K S (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                    (nat_add_succ_r k0 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
        DiagramMap_comm :=
          fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
          match
            p as p0 in (_ = n0)
            return
              (match
                 p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
               with
               | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
               end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
               transport idmap (ap A (nat_add_succ_r n0 n))
                 (match
                    p0 in (_ = n1) return (A (k0 + n.+1) -> A (n1 + n.+1))
                  with
                  | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                  end a0))
          with
          | 1 =>
              K S (fun (n0 : nat) (a1 : A n0) => a1 ^+) (nat_add_succ_r k0 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
            DiagramMap_comm :=
              fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
              match
                p as p0 in (_ = n0)
                return
                  (match
                     p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
                   with
                   | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
                   end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
                   transport idmap (ap A (nat_add_succ_r n0 n))
                     (match
                        p0 in (_ = n1)
                        return (A (k0 + n.+1) -> A (n1 + n.+1))
                      with
                      | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                      end a0))
              with
              | 1 =>
                  K S (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                    (nat_add_succ_r k0 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 k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
        DiagramMap_comm :=
          fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
          match
            p as p0 in (_ = n0)
            return
              (match
                 p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
               with
               | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
               end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
               transport idmap (ap A (nat_add_succ_r n0 n))
                 (match
                    p0 in (_ = n1) return (A (k0 + n.+1) -> A (n1 + n.+1))
                  with
                  | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                  end a0))
          with
          | 1 =>
              K S (fun (n0 : nat) (a1 : A n0) => a1 ^+) (nat_add_succ_r k0 n)
          end
      |} 1 a)^ @
 ap (colim_shift_seq_to_colim_seq A n)
   (colimp k.+1 k.+2 1
      ({|
         DiagramMap_obj :=
           fun k0 : nat => transport idmap (ap A (nat_add_succ_r k0 n));
         DiagramMap_comm :=
           fun (k0 l : nat) (p : k0.+1 = l) (a0 : A (k0 + n.+1)) =>
           match
             p as p0 in (_ = n0)
             return
               (match
                  p0 in (_ = n1) return (A (k0 + n).+1 -> A (n1 + n).+1)
                with
                | 1 => fun a1 : A (k0 + n).+1 => a1 ^+
                end (transport idmap (ap A (nat_add_succ_r k0 n)) a0) =
                transport idmap (ap A (nat_add_succ_r n0 n))
                  (match
                     p0 in (_ = n1) return (A (k0 + n.+1) -> A (n1 + n.+1))
                   with
                   | 1 => fun a1 : A (k0 + n.+1) => a1 ^+
                   end a0))
           with
           | 1 =>
               K S (fun (n0 : nat) (a1 : A n0) => a1 ^+)
                 (nat_add_succ_r k0 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 (n0 : nat) (_ : (fun _ : nat => Unit) n0) => 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 (n0 : nat) (_ : (fun _ : nat => Unit) n0) => 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 (k0 : nat) (h0 : {x : _ & A x} -> Type) => ?Goal0@{k:=k0; h:=h0}) k x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k0 : nat) (h0 : {x : _ & A x} -> Type) => ?Goal0@{k:=k0; h:=h0}) k.+1
  x
forall x : {x : _ & A x},
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k0 : nat) (h0 : {x : _ & A x} -> Type) => ?Goal0@{k:=k0; h:=h0}) k.+1
  x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type) ?Goal
  (fun (k0 : nat) (h0 : {x : _ & A x} -> Type) => ?Goal0@{k:=k0; h:=h0}) 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) (h0 : {x : _ & A x} -> Type) (x0 : {x : _ & A x}) =>
   h0 x0 ^++)
  k x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h0 : {x : _ & A x} -> Type) (x0 : {x : _ & A x}) =>
   h0 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) (h0 : {x : _ & A x} -> Type) (x0 : {x : _ & A x}) =>
   h0 x0 ^++)
  k.+1 x ->
nat_rect (fun _ : nat => {x : _ & A x} -> Type)
  (fun x0 : {x : _ & A x} => B x0)
  (fun (_ : nat) (h0 : {x : _ & A x} -> Type) (x0 : {x : _ & A x}) =>
   h0 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 x1 : {x : _ & A x},
       fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (fun x1 : {x : _ & A x} => idmap)
      (fun (n0 : nat)
         (e : forall x1 : {x : _ & A x},
              fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
         (x1 : {x : _ & A x}) =>
       coe (ap B (seq_pair_shift_assoc x1 n0)) o e x1 ^++)
      n x)
     i x0) =
(fun n : Graph.graph0 sequence_graph =>
 nat_rect
   (fun n0 : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (x1 : {x : _ & A x}) =>
    coe (ap B (seq_pair_shift_assoc x1 n0)) o e x1 ^++)
   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 n0 : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
    equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
      (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
   n x x0)
^+ =
nat_rect
  (fun n0 : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n0 : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
     (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
   equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
     (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
  n.+1 x x0 ^+
forall (x : {x : _ & A x}) (x0 : fib_seq_to_seq B x n.+1),
(nat_rect
   (fun n0 : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
    equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
      (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
   n.+1 x x0)
^+ =
nat_rect
  (fun n0 : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n0 : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
     (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
   equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
     (ap B (seq_pair_shift_assoc x1 n0)) (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 n0 : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
    equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
      (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
   n x x0)
^+ =
nat_rect
  (fun n0 : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n0 : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
     (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
   equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
     (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
  n.+1 x x0 ^+
forall (x : {x : _ & A x}) (x0 : fib_seq_to_seq B x n.+1),
(nat_rect
   (fun n0 : nat =>
    forall x1 : {x : _ & A x},
    fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
   (fun x1 : {x : _ & A x} => idmap)
   (fun (n0 : nat)
      (e : forall x1 : {x : _ & A x},
           fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
      (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
    equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
      (ap B (seq_pair_shift_assoc x1 n0)) (e x1 ^++ x2))
   n.+1 x x0)
^+ =
nat_rect
  (fun n0 : nat =>
   forall x1 : {x : _ & A x},
   fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
  (fun x1 : {x : _ & A x} => idmap)
  (fun (n0 : nat)
     (e : forall x1 : {x : _ & A x},
          fib_seq_to_seq B x1 n0 -> fib_seq_to_seq' B x1 n0)
     (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n0) =>
   equiv_path (B (x1 ^++) ^++ n0) (B x1 ^++ (n0.+1))
     (ap B (seq_pair_shift_assoc x1 n0)) (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 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}) =>
          coe (ap B (seq_pair_shift_assoc x0 n0)) o e x0 ^++)
         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 : _ & 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 ^+)
                (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
                      (((fix F (n1 : nat) :
                             (fun _ : nat => {x : _ & A x}) n1 :=
                           match
                             n1 as n2
                             return ((fun _ : nat => {x : _ & A x}) n2)
                           with
                           | 0 => x0
                           | n2.+1 =>
                               (fun (_ : nat) (y : {x : _ & A x}) => y ^++)
                                 n2 (F n2)
                           end)
                          n0)
                       ^++)
                      ^++)
                   (ap B (ap seq_pair_shift (seq_pair_shift_assoc x0 n0))))
                (p0 x0 ^++ 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 : _ & 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 ^+)
                (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 n0 : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n1 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n1 : nat)
            (e0 : forall x0 : {x : _ & A x},
                  fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
            (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 ^++ n1) =>
          equiv_path (B (x0 ^++) ^++ n1) (B x0 ^++ (n1.+1))
            (ap B (seq_pair_shift_assoc x0 n1)) (e0 x0 ^++ x1))
         n0 x;
     DiagramMap_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       match
         p as p0 in (_ = n1)
         return
           (forall x0 : fib_seq_to_seq B x n0,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n2 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x1 : {x : _ & A x},
                          fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                    (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
                  equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x1 n2)) 
                    (e0 x1 ^++ x2))
                 n0 x x0) =
            nat_rect
              (fun n2 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n2 : nat)
                 (e0 : forall x1 : {x : _ & A x},
                       fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
               equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                 (ap B (seq_pair_shift_assoc x1 n2)) 
                 (e0 x1 ^++ x2))
              n1 x (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n1 : nat =>
              forall (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 n1),
              (nat_rect
                 (fun n2 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                    (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                  equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x2 n2)) 
                    (e0 x2 ^++ x3))
                 n1 x0 x1)
              ^+ =
              nat_rect
                (fun n2 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n2 : nat)
                   (e0 : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                   (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                 equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                   (ap B (seq_pair_shift_assoc x2 n2)) 
                   (e0 x2 ^++ x3))
                n1.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n1 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n1),
                      (nat_rect
                         (fun n2 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                         (fun x2 : {x : _ & A x} => idmap)
                         (fun (n2 : nat)
                            (e0 : forall x2 : {x : _ & A x},
                                  fib_seq_to_seq B x2 n2 ->
                                  fib_seq_to_seq' B x2 n2)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                          equiv_path (B (x2 ^++) ^++ n2) 
                            (B x2 ^++ (n2.+1))
                            (ap B (seq_pair_shift_assoc x2 n2))
                            (e0 x2 ^++ x3))
                         n1 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n2 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                        (fun x2 : {x : _ & A x} => idmap)
                        (fun (n2 : nat)
                           (e0 : forall x2 : {x : _ & A x},
                                 fib_seq_to_seq B x2 n2 ->
                                 fib_seq_to_seq' B x2 n2)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                         equiv_path (B (x2 ^++) ^++ n2) 
                           (B x2 ^++ (n2.+1))
                           (ap B (seq_pair_shift_assoc x2 n2)) 
                           (e0 x2 ^++ x3))
                        n1.+1 x0 x1 ^+)
                (x0 : {x : _ & A x}) (b : fib_seq_to_seq B x0 n1.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n1) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n1) ^++)
                   (B ((nat_iter n1 seq_pair_shift x0) ^++) ^++)
                   (ap B (ap seq_pair_shift (seq_pair_shift_assoc x0 n1))))
                (p0 x0 ^++ b))
             n0 x
       end
   |} n)
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n0 : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n1 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n1 : nat)
            (e0 : forall x0 : {x : _ & A x},
                  fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
            (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 ^++ n1) =>
          equiv_path (B (x0 ^++) ^++ n1) (B x0 ^++ (n1.+1))
            (ap B (seq_pair_shift_assoc x0 n1)) (e0 x0 ^++ x1))
         n0 x;
     DiagramMap_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       match
         p as p0 in (_ = n1)
         return
           (forall x0 : fib_seq_to_seq B x n0,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n2 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x1 : {x : _ & A x},
                          fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                    (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
                  equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x1 n2)) 
                    (e0 x1 ^++ x2))
                 n0 x x0) =
            nat_rect
              (fun n2 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n2 : nat)
                 (e0 : forall x1 : {x : _ & A x},
                       fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
               equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                 (ap B (seq_pair_shift_assoc x1 n2)) 
                 (e0 x1 ^++ x2))
              n1 x (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n1 : nat =>
              forall (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 n1),
              (nat_rect
                 (fun n2 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                    (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                  equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x2 n2)) 
                    (e0 x2 ^++ x3))
                 n1 x0 x1)
              ^+ =
              nat_rect
                (fun n2 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n2 : nat)
                   (e0 : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                   (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                 equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                   (ap B (seq_pair_shift_assoc x2 n2)) 
                   (e0 x2 ^++ x3))
                n1.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n1 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n1),
                      (nat_rect
                         (fun n2 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                         (fun x2 : {x : _ & A x} => idmap)
                         (fun (n2 : nat)
                            (e0 : forall x2 : {x : _ & A x},
                                  fib_seq_to_seq B x2 n2 ->
                                  fib_seq_to_seq' B x2 n2)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                          equiv_path (B (x2 ^++) ^++ n2) 
                            (B x2 ^++ (n2.+1))
                            (ap B (seq_pair_shift_assoc x2 n2))
                            (e0 x2 ^++ x3))
                         n1 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n2 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                        (fun x2 : {x : _ & A x} => idmap)
                        (fun (n2 : nat)
                           (e0 : forall x2 : {x : _ & A x},
                                 fib_seq_to_seq B x2 n2 ->
                                 fib_seq_to_seq' B x2 n2)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                         equiv_path (B (x2 ^++) ^++ n2) 
                           (B x2 ^++ (n2.+1))
                           (ap B (seq_pair_shift_assoc x2 n2)) 
                           (e0 x2 ^++ x3))
                        n1.+1 x0 x1 ^+)
                (x0 : {x : _ & A x}) (b : fib_seq_to_seq B x0 n1.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n1) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n1) ^++)
                   (B ((nat_iter n1 seq_pair_shift x0) ^++) ^++)
                   (ap B (ap seq_pair_shift (seq_pair_shift_assoc x0 n1))))
                (p0 x0 ^++ b))
             n0 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 : _ & 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 ^+)
                (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 n0 : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n1 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n1 : nat)
            (e0 : forall x0 : {x : _ & A x},
                  fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
            (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 ^++ n1) =>
          equiv_path (B (x0 ^++) ^++ n1) (B x0 ^++ (n1.+1))
            (ap B (seq_pair_shift_assoc x0 n1)) (e0 x0 ^++ x1))
         n0 x;
     DiagramMap_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       match
         p as p0 in (_ = n1)
         return
           (forall x0 : fib_seq_to_seq B x n0,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n2 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x1 : {x : _ & A x},
                          fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                    (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
                  equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x1 n2)) 
                    (e0 x1 ^++ x2))
                 n0 x x0) =
            nat_rect
              (fun n2 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n2 : nat)
                 (e0 : forall x1 : {x : _ & A x},
                       fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
               equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                 (ap B (seq_pair_shift_assoc x1 n2)) 
                 (e0 x1 ^++ x2))
              n1 x (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n1 : nat =>
              forall (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 n1),
              (nat_rect
                 (fun n2 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                    (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                  equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x2 n2)) 
                    (e0 x2 ^++ x3))
                 n1 x0 x1)
              ^+ =
              nat_rect
                (fun n2 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n2 : nat)
                   (e0 : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                   (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                 equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                   (ap B (seq_pair_shift_assoc x2 n2)) 
                   (e0 x2 ^++ x3))
                n1.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n1 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n1),
                      (nat_rect
                         (fun n2 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                         (fun x2 : {x : _ & A x} => idmap)
                         (fun (n2 : nat)
                            (e0 : forall x2 : {x : _ & A x},
                                  fib_seq_to_seq B x2 n2 ->
                                  fib_seq_to_seq' B x2 n2)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                          equiv_path (B (x2 ^++) ^++ n2) 
                            (B x2 ^++ (n2.+1))
                            (ap B (seq_pair_shift_assoc x2 n2))
                            (e0 x2 ^++ x3))
                         n1 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n2 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                        (fun x2 : {x : _ & A x} => idmap)
                        (fun (n2 : nat)
                           (e0 : forall x2 : {x : _ & A x},
                                 fib_seq_to_seq B x2 n2 ->
                                 fib_seq_to_seq' B x2 n2)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                         equiv_path (B (x2 ^++) ^++ n2) 
                           (B x2 ^++ (n2.+1))
                           (ap B (seq_pair_shift_assoc x2 n2)) 
                           (e0 x2 ^++ x3))
                        n1.+1 x0 x1 ^+)
                (x0 : {x : _ & A x}) (b : fib_seq_to_seq B x0 n1.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n1) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n1) ^++)
                   (B ((nat_iter n1 seq_pair_shift x0) ^++) ^++)
                   (ap B (ap seq_pair_shift (seq_pair_shift_assoc x0 n1))))
                (p0 x0 ^++ b))
             n0 x
       end
   |} n)
forall x : {x : _ & A x},
IsEquiv
  ({|
     DiagramMap_obj :=
       fun n0 : Graph.graph0 sequence_graph =>
       nat_rect
         (fun n1 : nat =>
          forall x0 : {x : _ & A x},
          fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
         (fun x0 : {x : _ & A x} => idmap)
         (fun (n1 : nat)
            (e0 : forall x0 : {x : _ & A x},
                  fib_seq_to_seq B x0 n1 -> fib_seq_to_seq' B x0 n1)
            (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 ^++ n1) =>
          equiv_path (B (x0 ^++) ^++ n1) (B x0 ^++ (n1.+1))
            (ap B (seq_pair_shift_assoc x0 n1)) (e0 x0 ^++ x1))
         n0 x;
     DiagramMap_comm :=
       fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) =>
       match
         p as p0 in (_ = n1)
         return
           (forall x0 : fib_seq_to_seq B x n0,
            ((fib_seq_to_seq' B x) _f p0)
              (nat_rect
                 (fun n2 : nat =>
                  forall x1 : {x : _ & A x},
                  fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (fun x1 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x1 : {x : _ & A x},
                          fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                    (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
                  equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x1 n2)) 
                    (e0 x1 ^++ x2))
                 n0 x x0) =
            nat_rect
              (fun n2 : nat =>
               forall x1 : {x : _ & A x},
               fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
              (fun x1 : {x : _ & A x} => idmap)
              (fun (n2 : nat)
                 (e0 : forall x1 : {x : _ & A x},
                       fib_seq_to_seq B x1 n2 -> fib_seq_to_seq' B x1 n2)
                 (x1 : {x : _ & A x}) (x2 : fib_seq_to_seq B x1 ^++ n2) =>
               equiv_path (B (x1 ^++) ^++ n2) (B x1 ^++ (n2.+1))
                 (ap B (seq_pair_shift_assoc x1 n2)) 
                 (e0 x1 ^++ x2))
              n1 x (((fib_seq_to_seq B x) _f p0) x0))
       with
       | 1 =>
           nat_rect
             (fun n1 : nat =>
              forall (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 n1),
              (nat_rect
                 (fun n2 : nat =>
                  forall x2 : {x : _ & A x},
                  fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                 (fun x2 : {x : _ & A x} => idmap)
                 (fun (n2 : nat)
                    (e0 : forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                    (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                  equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                    (ap B (seq_pair_shift_assoc x2 n2)) 
                    (e0 x2 ^++ x3))
                 n1 x0 x1)
              ^+ =
              nat_rect
                (fun n2 : nat =>
                 forall x2 : {x : _ & A x},
                 fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                (fun x2 : {x : _ & A x} => idmap)
                (fun (n2 : nat)
                   (e0 : forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                   (x2 : {x : _ & A x}) (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                 equiv_path (B (x2 ^++) ^++ n2) (B x2 ^++ (n2.+1))
                   (ap B (seq_pair_shift_assoc x2 n2)) 
                   (e0 x2 ^++ x3))
                n1.+1 x0 x1 ^+)
             (fun (x0 : {x : _ & A x}) (x1 : fib_seq_to_seq B x0 0) => 1)
             (fun (n1 : nat)
                (p0 : forall (x0 : {x : _ & A x})
                      (x1 : fib_seq_to_seq B x0 n1),
                      (nat_rect
                         (fun n2 : nat =>
                          forall x2 : {x : _ & A x},
                          fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                         (fun x2 : {x : _ & A x} => idmap)
                         (fun (n2 : nat)
                            (e0 : forall x2 : {x : _ & A x},
                                  fib_seq_to_seq B x2 n2 ->
                                  fib_seq_to_seq' B x2 n2)
                            (x2 : {x : _ & A x})
                            (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                          equiv_path (B (x2 ^++) ^++ n2) 
                            (B x2 ^++ (n2.+1))
                            (ap B (seq_pair_shift_assoc x2 n2))
                            (e0 x2 ^++ x3))
                         n1 x0 x1)
                      ^+ =
                      nat_rect
                        (fun n2 : nat =>
                         forall x2 : {x : _ & A x},
                         fib_seq_to_seq B x2 n2 -> fib_seq_to_seq' B x2 n2)
                        (fun x2 : {x : _ & A x} => idmap)
                        (fun (n2 : nat)
                           (e0 : forall x2 : {x : _ & A x},
                                 fib_seq_to_seq B x2 n2 ->
                                 fib_seq_to_seq' B x2 n2)
                           (x2 : {x : _ & A x})
                           (x3 : fib_seq_to_seq B x2 ^++ n2) =>
                         equiv_path (B (x2 ^++) ^++ n2) 
                           (B x2 ^++ (n2.+1))
                           (ap B (seq_pair_shift_assoc x2 n2)) 
                           (e0 x2 ^++ x3))
                        n1.+1 x0 x1 ^+)
                (x0 : {x : _ & A x}) (b : fib_seq_to_seq B x0 n1.+1) =>
              K seq_pair_shift (fibSequenceArr B)
                (seq_pair_shift_assoc x0 n1) @
              ap
                (equiv_path (B ((x0 ^++) ^++ n1) ^++)
                   (B ((nat_iter n1 seq_pair_shift x0) ^++) ^++)
                   (ap B (ap seq_pair_shift (seq_pair_shift_assoc x0 n1))))
                (p0 x0 ^++ b))
             n0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0) =>
         Colimit (fib_seq_to_seq B (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
              (Colimit (fib_seq_to_seq B (n1; (A _f p0) a0)) =
               Colimit (fib_seq_to_seq B (n0; a0)))
          with
          | 1 =>
              path_universe_uncurried
                (equiv_colim_succ_seq_to_colim_seq
                   (fib_seq_to_seq B (n0; a0)))
          end)
         :
         (fun (n1 : Graph.graph0 sequence_graph) (a0 : A n1) =>
          Colimit (fib_seq_to_seq B (n1; a0))) m
         o A _f p ==
         (fun (n1 : Graph.graph0 sequence_graph) (a0 : A n1) =>
          Colimit (fib_seq_to_seq B (n1; a0))) n0
     |} 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 a0 : A n => B (n; a0)) 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 a0 : A n => B (n; a0)) 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
k: nat
h: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : fib_seq_to_seq B (n0; a0) k),
transport (fun x : fib_seq_to_type_fam B (inj A n0 a0) => E (inj A n0 a0; x))
  (colimp k k.+1 1 b0) (Q k.+1 n0 a0 b0 ^+) =
Q k n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b)))
  (e n0.+1 a0 ^+ b ^+f) =
e n0 a0 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 y0 : Y x1,
(fun y1 : Y x2 => G (x2; y1)) (F y0) =
transport Z (Delta p psi y0) ((fun y1 : Y x1 => G (x1; y1)) y0)
theta: I psi (apD (fun (x : X) (y0 : Y x) => G (x; y0)) 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 y0 : Y x1,
(fun y1 : Y x2 => G (x2; y1)) (F y0) =
transport Z (Delta p psi y0) ((fun y1 : Y x1 => G (x1; y1)) y0)
theta: I psi (apD (fun (x : X) (y0 : Y x) => G (x; y0)) 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
E (seq_colim_sum_to_sum_seq_colim B (inj (sig_seq B) n0 (a0; b0)))
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
(b0 : (fun a1 : A n0 => B (n0; a1)) a0),
transport E
  (ap (seq_colim_sum_to_sum_seq_colim B) (glue (sig_seq B) n0 (a0; b0)))
  (e n0.+1 a0 ^+ b0 ^+f) =
e n0 a0 b0
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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0), B (n0; a0) -> E
t: forall (n0 : Graph.graph0 sequence_graph) (a0 : A n0) 
(b0 : B (n0; a0)), e n0.+1 a0 ^+ b0 ^+f = e n0 a0 b0
n: Graph.graph0 sequence_graph
a: A n
b: (fun a0 : A n => B (n; a0)) 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 a0 : A n => B (n; a0)) 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 (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
      (b0 : (fun a1 : A n0 => B (n0; a1)) a0) =>
    h (inj (sig_seq B) n0 (a0; b0))) n.+1 a ^+ b ^+f) =
(fun (n0 : Graph.graph0 sequence_graph) (a0 : A n0)
   (b0 : (fun a1 : A n0 => B (n0; a1)) a0) =>
 h (inj (sig_seq B) n0 (a0; b0))) 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
{G0
: {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) => G0 (seq_colim_sum_to_sum_seq_colim B x)) ==
idmap}
H: Univalence
A: Sequence
B: FibSequence A
L: {G0
: {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})
& G0 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
{G0
: {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) => G0 (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
   G0 : {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) => G0 (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
   G0 : {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) => G0 (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 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}))
     (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)) =>
      colimp n0 n0.+1 1 (a0; 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: {G0
: {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})
& G0 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: {G0
: {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})
& G0 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 (n0 : Graph.graph0 sequence_graph) (X : sig_seq B n0) =>
         (inj A n0 X.1; inj (fib_seq_to_seq B (n0; X.1)) 0 X.2);
       legs_comm :=
         fun (n0 m : Graph.graph0 sequence_graph)
           (p : Graph.graph1 sequence_graph n0 m) 
           (x : sig_seq B n0) =>
         match
           p as p0 in (_ = n1)
           return
             ((inj A n1 (((sig_seq B) _f p0) (x.1; x.2)).1;
              inj (fib_seq_to_seq B (n1; (((sig_seq B) _f p0) (x.1; x.2)).1))
                0 (((sig_seq B) _f p0) (x.1; x.2)).2) =
              (inj A n0 x.1; inj (fib_seq_to_seq B (n0; x.1)) 0 x.2))
         with
         | 1 =>
             Delta (colimp n0 n0.+1 1 x.1)
               (fib_seq_to_type_fam_beta_glue B n0 x.1)
               (inj (fib_seq_to_seq B (n0.+1; ((x.1; x.2) ^+).1)) 0
                  ((x.1; x.2) ^+).2) @
             ap (exist (fib_seq_to_type_fam B) (inj A n0 x.1))
               (colimp 0 1 1 x.2)
         end
     |} n n.+1 1 (a; b)) =
legs_comm
  {|
    legs :=
      fun (n0 : Graph.graph0 sequence_graph) (X : sig_seq B n0) =>
      inj A n0 X.1;
    legs_comm :=
      fun (n0 m : Graph.graph0 sequence_graph)
        (p : Graph.graph1 sequence_graph n0 m) (x : sig_seq B n0) =>
      match
        p as p0 in (_ = n1)
        return (inj A n1 (((sig_seq B) _f p0) (x.1; x.2)).1 = inj A n0 x.1)
      with
      | 1 => colimp n0 n0.+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 (n0 : Graph.graph0 sequence_graph) (X : sig_seq B n0) =>
      inj A n0 X.1;
    legs_comm :=
      fun (n0 m : Graph.graph0 sequence_graph)
        (p : Graph.graph1 sequence_graph n0 m) (x : sig_seq B n0) =>
      match
        p as p0 in (_ = n1)
        return (inj A n1 (((sig_seq B) _f p0) (x.1; x.2)).1 = inj A n0 x.1)
      with
      | 1 => colimp n0 n0.+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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 n0 : Graph.graph0 sequence_graph, IsTrunc k (A n0)) ->
IsTrunc k (Colimit A)
n: nat
IHn: forall A : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)) ->
forall (x : A n) (y : Colimit A), IsTrunc k (inj A n x = y)
forall A : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)) ->
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
m: nat
IHm: forall A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
forall (a0 : A0 0%nat) (b0 : A0 m), IsTrunc k (inj A0 0%nat a0 = inj A0 m b0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
m: nat
IHm: forall A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
forall (a0 : A0 0%nat) (b0 : A0 m), IsTrunc k (inj A0 0%nat a0 = inj A0 m b0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
m: nat
IHm: forall A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
forall (a0 : A0 0%nat) (b0 : A0 m), IsTrunc k (inj A0 0%nat a0 = inj A0 m b0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
       (forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
       forall (a0 : A0 0%nat) (b0 : A0 m0),
       IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
      (fun (A0 : Sequence)
         (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
         (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 n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
                forall (a0 : A0 0%nat) (b0 : A0 m0),
                IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
         (A0 : Sequence)
         (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
         (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)
     j ((A _f g) x)) =
(fun (m : Graph.graph0 sequence_graph) (b : A m) =>
 nat_rect
   (fun m0 : nat =>
    forall A0 : Sequence,
    (forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
    forall (a0 : A0 0%nat) (b0 : A0 m0),
    IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
   (fun (A0 : Sequence)
      (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
      (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 n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
             forall (a0 : A0 0%nat) (b0 : A0 m0),
             IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
      (A0 : Sequence)
      (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
      (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)
  i x
        {
H: Univalence
k: trunc_index
IHk: forall A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
       (forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
       forall (a0 : A0 0%nat) (b0 : A0 m0),
       IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
      (fun (A0 : Sequence)
         (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
         (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 n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
                forall (a0 : A0 0%nat) (b0 : A0 m0),
                IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
         (A0 : Sequence)
         (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
         (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)
     j ((A _f g) x)) =
(fun (m : Graph.graph0 sequence_graph) (b : A m) =>
 nat_rect
   (fun m0 : nat =>
    forall A0 : Sequence,
    (forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
    forall (a0 : A0 0%nat) (b0 : A0 m0),
    IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
   (fun (A0 : Sequence)
      (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
      (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 n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n)) ->
             forall (a0 : A0 0%nat) (b0 : A0 m0),
             IsTrunc k (inj A0 0%nat a0 = inj A0 m0 b0))
      (A0 : Sequence)
      (trH0 : forall n : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n))
      (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)
  i x intros n m p b; snapply path_ishprop; snapply ishprop_istrunc; exact _. }
      *
H: Univalence
k: trunc_index
IHk: forall A : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k (A n0)) ->
IsTrunc k (Colimit A)
n: nat
IHn: forall A : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)) ->
forall (x : A n) (y : Colimit A), IsTrunc k (inj A n x = y)
forall A : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)) ->
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 A0 : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k (A0 n0)) ->
IsTrunc k (Colimit A0)
n: nat
IHn: forall A0 : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n0)) ->
forall (x : A0 n) (y : Colimit A0), IsTrunc k (inj A0 n x = y)
A: Sequence
trH: forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)
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 A0 : Sequence,
(forall n : Graph.graph0 sequence_graph, IsTrunc k (A0 n)) ->
IsTrunc k (Colimit A0)
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 A0 : Sequence,
       (forall n1 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n1)) ->
       forall (x0 : A0 n0) (y : Colimit A0), IsTrunc k (inj A0 n0 x0 = y))
      (fun (A0 : Sequence)
         (trH0 : forall n0 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A0 n0))
         (a : A0 0%nat) =>
       Colimit_ind (fun w : Colimit A0 => IsTrunc k (inj A0 0%nat a = w))
         (fun (m : Graph.graph0 sequence_graph) (b : A0 m) =>
          nat_rect
            (fun m0 : nat =>
             forall A1 : Sequence,
             (forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A1 n0)) ->
             forall (a0 : A1 0%nat) (b0 : A1 m0),
             IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
            (fun (A1 : Sequence)
               (trH1 : forall n0 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n0))
               (a0 b0 : A1 0%nat) =>
             istrunc_equiv_istrunc
               (Colimit (path_seq (shift_seq A1 0) a0 b0))
               (equiv_path_colim 0%nat a0 b0)^-1)
            (fun (m0 : nat)
               (IHm : forall A1 : Sequence,
                      (forall n0 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n0)) ->
                      forall (a0 : A1 0%nat) (b0 : A1 m0),
                      IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
               (A1 : Sequence)
               (trH1 : forall n0 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n0))
               (a0 : A1 0%nat) (b0 : A1 m0.+1%nat) =>
             istrunc_equiv_istrunc (inj A1 1%nat a0 ^+ = inj A1 m0.+1%nat b0)
               (equiv_concat_l (glue A1 0%nat a0) (inj A1 m0.+1%nat b0))^-1)
            m A0 trH0 a b)
         (fun (n0 m : Graph.graph0 sequence_graph)
            (p : Graph.graph1 sequence_graph n0 m) 
            (b : A0 n0) =>
          path_ishprop
            (transport (fun w : Colimit A0 => IsTrunc k (inj A0 0%nat a = w))
               (colimp n0 m p b)
               ((fun (m0 : Graph.graph0 sequence_graph) (b0 : A0 m0) =>
                 nat_rect
                   (fun m1 : nat =>
                    forall A1 : Sequence,
                    (forall n1 : Graph.graph0 sequence_graph,
                     IsTrunc k.+1 (A1 n1)) ->
                    forall (a0 : A1 0%nat) (b1 : A1 m1),
                    IsTrunc k (inj A1 0%nat a0 = inj A1 m1 b1))
                   (fun (A1 : Sequence)
                      (trH1 : forall n1 : Graph.graph0 sequence_graph,
                              IsTrunc k.+1 (A1 n1))
                      (a0 b1 : A1 0%nat) =>
                    istrunc_equiv_istrunc
                      (Colimit (path_seq (shift_seq A1 0) a0 b1))
                      (equiv_path_colim 0%nat a0 b1)^-1)
                   (fun (m1 : nat)
                      (IHm : forall A1 : Sequence,
                             (forall n1 : Graph.graph0 sequence_graph,
                              IsTrunc k.+1 (A1 n1)) ->
                             forall (a0 : A1 0%nat) 
                             (b1 : A1 m1),
                             IsTrunc k (inj A1 0%nat a0 = inj A1 m1 b1))
                      (A1 : Sequence)
                      (trH1 : forall n1 : Graph.graph0 sequence_graph,
                              IsTrunc k.+1 (A1 n1))
                      (a0 : A1 0%nat) (b1 : A1 m1.+1%nat) =>
                    istrunc_equiv_istrunc
                      (inj A1 1%nat a0 ^+ = inj A1 m1.+1%nat b1)
                      (equiv_concat_l (glue A1 0%nat a0)
                         (inj A1 m1.+1%nat b1))^-1)
                   m0 A0 trH0 a b0)
                  m ((A0 _f p) b)))
            (nat_rect
               (fun m0 : nat =>
                forall A1 : Sequence,
                (forall n1 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A1 n1)) ->
                forall (a0 : A1 0%nat) (b0 : A1 m0),
                IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
               (fun (A1 : Sequence)
                  (trH1 : forall n1 : Graph.graph0 sequence_graph,
                          IsTrunc k.+1 (A1 n1))
                  (a0 b0 : A1 0%nat) =>
                istrunc_equiv_istrunc
                  (Colimit (path_seq (shift_seq A1 0) a0 b0))
                  (equiv_path_colim 0%nat a0 b0)^-1)
               (fun (m0 : nat)
                  (IHm : forall A1 : Sequence,
                         (forall n1 : Graph.graph0 sequence_graph,
                          IsTrunc k.+1 (A1 n1)) ->
                         forall (a0 : A1 0%nat) (b0 : A1 m0),
                         IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
                  (A1 : Sequence)
                  (trH1 : forall n1 : Graph.graph0 sequence_graph,
                          IsTrunc k.+1 (A1 n1))
                  (a0 : A1 0%nat) (b0 : A1 m0.+1%nat) =>
                istrunc_equiv_istrunc
                  (inj A1 1%nat a0 ^+ = inj A1 m0.+1%nat b0)
                  (equiv_concat_l (glue A1 0%nat a0) (inj A1 m0.+1%nat b0))^-1)
               n0 A0 trH0 a b)))
      (fun (n0 : nat)
         (IHn : forall A0 : Sequence,
                (forall n1 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A0 n1)) ->
                forall (x0 : A0 n0) (y : Colimit A0),
                IsTrunc k (inj A0 n0 x0 = y))
         (A0 : Sequence)
         (trH0 : forall n1 : Graph.graph0 sequence_graph,
                 IsTrunc k.+1 (A0 n1))
         (a : A0 n0.+1%nat) =>
       functor_forall_equiv_pb (colim_succ_seq_to_colim_seq A0)
         (fun x0 : Colimit (succ_seq A0) =>
          istrunc_equiv_istrunc (inj (succ_seq A0) n0 a = x0)
            (equiv_ap (colim_succ_seq_to_colim_seq A0)
               (inj (succ_seq A0) n0 a) x0)))
      n A trH)
     j ((A _f g) x)) =
(fun n : Graph.graph0 sequence_graph =>
 nat_rect
   (fun n0 : nat =>
    forall A0 : Sequence,
    (forall n1 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n1)) ->
    forall (x0 : A0 n0) (y : Colimit A0), IsTrunc k (inj A0 n0 x0 = y))
   (fun (A0 : Sequence)
      (trH0 : forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n0))
      (a : A0 0%nat) =>
    Colimit_ind (fun w : Colimit A0 => IsTrunc k (inj A0 0%nat a = w))
      (fun (m : Graph.graph0 sequence_graph) (b : A0 m) =>
       nat_rect
         (fun m0 : nat =>
          forall A1 : Sequence,
          (forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A1 n0)) ->
          forall (a0 : A1 0%nat) (b0 : A1 m0),
          IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
         (fun (A1 : Sequence)
            (trH1 : forall n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A1 n0))
            (a0 b0 : A1 0%nat) =>
          istrunc_equiv_istrunc (Colimit (path_seq (shift_seq A1 0) a0 b0))
            (equiv_path_colim 0%nat a0 b0)^-1)
         (fun (m0 : nat)
            (IHm : forall A1 : Sequence,
                   (forall n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A1 n0)) ->
                   forall (a0 : A1 0%nat) (b0 : A1 m0),
                   IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
            (A1 : Sequence)
            (trH1 : forall n0 : Graph.graph0 sequence_graph,
                    IsTrunc k.+1 (A1 n0))
            (a0 : A1 0%nat) (b0 : A1 m0.+1%nat) =>
          istrunc_equiv_istrunc (inj A1 1%nat a0 ^+ = inj A1 m0.+1%nat b0)
            (equiv_concat_l (glue A1 0%nat a0) (inj A1 m0.+1%nat b0))^-1)
         m A0 trH0 a b)
      (fun (n0 m : Graph.graph0 sequence_graph)
         (p : Graph.graph1 sequence_graph n0 m) (b : A0 n0) =>
       path_ishprop
         (transport (fun w : Colimit A0 => IsTrunc k (inj A0 0%nat a = w))
            (colimp n0 m p b)
            ((fun (m0 : Graph.graph0 sequence_graph) (b0 : A0 m0) =>
              nat_rect
                (fun m1 : nat =>
                 forall A1 : Sequence,
                 (forall n1 : Graph.graph0 sequence_graph,
                  IsTrunc k.+1 (A1 n1)) ->
                 forall (a0 : A1 0%nat) (b1 : A1 m1),
                 IsTrunc k (inj A1 0%nat a0 = inj A1 m1 b1))
                (fun (A1 : Sequence)
                   (trH1 : forall n1 : Graph.graph0 sequence_graph,
                           IsTrunc k.+1 (A1 n1))
                   (a0 b1 : A1 0%nat) =>
                 istrunc_equiv_istrunc
                   (Colimit (path_seq (shift_seq A1 0) a0 b1))
                   (equiv_path_colim 0%nat a0 b1)^-1)
                (fun (m1 : nat)
                   (IHm : forall A1 : Sequence,
                          (forall n1 : Graph.graph0 sequence_graph,
                           IsTrunc k.+1 (A1 n1)) ->
                          forall (a0 : A1 0%nat) (b1 : A1 m1),
                          IsTrunc k (inj A1 0%nat a0 = inj A1 m1 b1))
                   (A1 : Sequence)
                   (trH1 : forall n1 : Graph.graph0 sequence_graph,
                           IsTrunc k.+1 (A1 n1))
                   (a0 : A1 0%nat) (b1 : A1 m1.+1%nat) =>
                 istrunc_equiv_istrunc
                   (inj A1 1%nat a0 ^+ = inj A1 m1.+1%nat b1)
                   (equiv_concat_l (glue A1 0%nat a0) (inj A1 m1.+1%nat b1))^-1)
                m0 A0 trH0 a b0)
               m ((A0 _f p) b)))
         (nat_rect
            (fun m0 : nat =>
             forall A1 : Sequence,
             (forall n1 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A1 n1)) ->
             forall (a0 : A1 0%nat) (b0 : A1 m0),
             IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
            (fun (A1 : Sequence)
               (trH1 : forall n1 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n1))
               (a0 b0 : A1 0%nat) =>
             istrunc_equiv_istrunc
               (Colimit (path_seq (shift_seq A1 0) a0 b0))
               (equiv_path_colim 0%nat a0 b0)^-1)
            (fun (m0 : nat)
               (IHm : forall A1 : Sequence,
                      (forall n1 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n1)) ->
                      forall (a0 : A1 0%nat) (b0 : A1 m0),
                      IsTrunc k (inj A1 0%nat a0 = inj A1 m0 b0))
               (A1 : Sequence)
               (trH1 : forall n1 : Graph.graph0 sequence_graph,
                       IsTrunc k.+1 (A1 n1))
               (a0 : A1 0%nat) (b0 : A1 m0.+1%nat) =>
             istrunc_equiv_istrunc (inj A1 1%nat a0 ^+ = inj A1 m0.+1%nat b0)
               (equiv_concat_l (glue A1 0%nat a0) (inj A1 m0.+1%nat b0))^-1)
            n0 A0 trH0 a b)))
   (fun (n0 : nat)
      (IHn : forall A0 : Sequence,
             (forall n1 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n1)) ->
             forall (x0 : A0 n0) (y : Colimit A0),
             IsTrunc k (inj A0 n0 x0 = y))
      (A0 : Sequence)
      (trH0 : forall n1 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A0 n1))
      (a : A0 n0.+1%nat) =>
    functor_forall_equiv_pb (colim_succ_seq_to_colim_seq A0)
      (fun x0 : Colimit (succ_seq A0) =>
       istrunc_equiv_istrunc (inj (succ_seq A0) n0 a = x0)
         (equiv_ap (colim_succ_seq_to_colim_seq A0) 
            (inj (succ_seq A0) 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 A0 : Sequence,
(forall n0 : Graph.graph0 sequence_graph, IsTrunc k (A0 n0)) ->
IsTrunc k (Colimit A0)
A: Sequence
trH: forall n0 : Graph.graph0 sequence_graph, IsTrunc k.+1 (A n0)
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.