Datasets:

phanerozoic
/

Coq-HoTT

statement stringlengths 1 5.81k	proof stringlengths 0 5.82k	type stringclasses 23 values	symbolic_name stringlengths 1 75	library stringclasses 92 values	filename stringclasses 522 values	imports listlengths 0 62	deps listlengths 0 64	docstring stringlengths 0 4.91k	source_url stringclasses 1 value	commit stringclasses 1 value
ecompose_e1 {A B} (e : A <~> B) : e oE 1 = e.	Proof. apply path_equiv; reflexivity. Defined.	Lemma	ecompose_e1	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]	The identity equivalence is a right unit.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_1e {A B} (e : A <~> B) : 1 oE e = e.	Proof. apply path_equiv; reflexivity. Defined.	Lemma	ecompose_1e	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]	The identity is a left unit.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_e_ee {A B C D} (e : A <~> B) (f : B <~> C) (g : C <~> D) : g oE (f oE e) = (g oE f) oE e.	Proof. apply path_equiv; reflexivity. Defined.	Definition	ecompose_e_ee	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]	Composition is associative.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_ee_e {A B C D} (e : A <~> B) (f : B <~> C) (g : C <~> D) : (g oE f) oE e = g oE (f oE e).	Proof. apply path_equiv; reflexivity. Defined.	Definition	ecompose_ee_e	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_eV {A B} (e : A <~> B) : e oE e^-1 = 1.	Proof. apply path_equiv; apply path_forall; intro; apply eisretr. Defined.	Lemma	ecompose_eV	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv", "path_forall" ]	The left inverse law.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_Ve {A B} (e : A <~> B) : e^-1 oE e = 1.	Proof. apply path_equiv; apply path_forall; intro; apply eissect. Defined.	Lemma	ecompose_Ve	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv", "path_forall" ]	The right inverse law.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_V_ee {A B C} (e : A <~> B) (f : B <~> C) : f^-1 oE (f oE e) = e.	Proof. apply path_equiv; apply path_forall; intro; simpl; apply eissect. Defined.	Definition	ecompose_V_ee	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv", "path_forall" ]	Several auxiliary theorems about canceling inverses across associativity. These are somewhat redundant, following from earlier theorems.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_e_Ve {A B C} (e : A <~> B) (f : C <~> B) : e oE (e^-1 oE f) = f.	Proof. apply path_equiv; apply path_forall; intro; simpl; apply eisretr. Defined.	Definition	ecompose_e_Ve	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv", "path_forall" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_ee_V {A B C} (e : A <~> B) (f : B <~> C) : (f oE e) oE e^-1 = f.	Proof. apply path_equiv; apply path_forall; intro; simpl; apply ap; apply eisretr. Defined.	Definition	ecompose_ee_V	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "path_equiv", "path_forall" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ecompose_eV_e {A B C} (e : B <~> A) (f : B <~> C) : (f oE e^-1) oE e = f.	Proof. apply path_equiv; apply path_forall; intro; simpl; apply ap; apply eissect. Defined.	Definition	ecompose_eV_e	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "path_equiv", "path_forall" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
einv_ee {A B C} (e : A <~> B) (f : B <~> C) : (f oE e)^-1 = e^-1 oE f^-1.	Proof. apply path_equiv; reflexivity. Defined.	Definition	einv_ee	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]	Inverse distributes over composition	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
einv_Ve {A B C} (e : A <~> C) (f : B <~> C) : (f^-1 oE e)^-1 = e^-1 oE f.	Proof. apply path_equiv; reflexivity. Defined.	Definition	einv_Ve	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
einv_eV {A B C} (e : C <~> A) (f : C <~> B) : (f oE e^-1)^-1 = e oE f^-1.	Proof. apply path_equiv; reflexivity. Defined.	Definition	einv_eV	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
einv_VV {A B C} (e : A <~> B) (f : B <~> C) : (e^-1 oE f^-1)^-1 = f oE e.	Proof. apply path_equiv; reflexivity. Defined.	Definition	einv_VV	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
einv_V {A B} (e : A <~> B) : (e^-1)^-1 = e.	Proof. apply path_equiv; reflexivity. Defined.	Definition	einv_V	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "path_equiv" ]	Inverse is an involution.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_Me {A B C} (e : B <~> A) (f : B <~> C) (g : A <~> C) : e = g^-1 oE f -> g oE e = f.	Proof. intro h. exact (ap (fun e => g oE e) h @ ecompose_e_Ve _ _). Defined.	Definition	emoveR_Me	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_e_Ve" ]	*** Theorems for moving things around in equations.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_eM {A B C} (e : B <~> A) (f : B <~> C) (g : A <~> C) : g = f oE e^-1 -> g oE e = f.	Proof. intro h. exact (ap (fun g => g oE e) h @ ecompose_eV_e _ _). Defined.	Definition	emoveR_eM	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_eV_e" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_Ve {A B C} (e : B <~> A) (f : B <~> C) (g : C <~> A) : e = g oE f -> g^-1 oE e = f.	Proof. intro h. exact (ap (fun e => g^-1 oE e) h @ ecompose_V_ee _ _). Defined.	Definition	emoveR_Ve	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_V_ee" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_eV {A B C} (e : A <~> B) (f : B <~> C) (g : A <~> C) : g = f oE e -> g oE e^-1 = f.	Proof. intro h. exact (ap (fun g => g oE e^-1) h @ ecompose_ee_V _ _). Defined.	Definition	emoveR_eV	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_ee_V" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_Me {A B C} (e : A <~> B) (f : A <~> C) (g : B <~> C) : g^-1 oE f = e -> f = g oE e.	Proof. intro h. exact ((ecompose_e_Ve _ _)^ @ ap (fun e => g oE e) h). Defined.	Definition	emoveL_Me	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_e_Ve" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_eM {A B C} (e : A <~> B) (f : A <~> C) (g : B <~> C) : f oE e^-1 = g -> f = g oE e.	Proof. intro h. exact ((ecompose_eV_e _ _)^ @ ap (fun g => g oE e) h). Defined.	Definition	emoveL_eM	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_eV_e" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_Ve {A B C} (e : A <~> C) (f : A <~> B) (g : B <~> C) : g oE f = e -> f = g^-1 oE e.	Proof. intro h. exact ((ecompose_V_ee _ _)^ @ ap (fun e => g^-1 oE e) h). Defined.	Definition	emoveL_Ve	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_V_ee" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_eV {A B C} (e : A <~> B) (f : B <~> C) (g : A <~> C) : f oE e = g -> f = g oE e^-1.	Proof. intro h. exact ((ecompose_ee_V _ _)^ @ ap (fun g => g oE e^-1) h). Defined.	Definition	emoveL_eV	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_ee_V" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_1M {A B} (e f : A <~> B) : e oE f^-1 = 1 -> e = f.	Proof. intro h. exact ((ecompose_eV_e _ _)^ @ ap (fun ef => ef oE f) h @ ecompose_1e _). Defined.	Definition	emoveL_1M	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_1e", "ecompose_eV_e" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_M1 {A B} (e f : A <~> B) : f^-1 oE e = 1 -> e = f.	Proof. intro h. exact ((ecompose_e_Ve _ _)^ @ ap (fun fe => f oE fe) h @ ecompose_e1 _). Defined.	Definition	emoveL_M1	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_e1", "ecompose_e_Ve" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_1V {A B} (e : A <~> B) (f : B <~> A) : e oE f = 1 -> e = f^-1.	Proof. intro h. exact ((ecompose_ee_V _ _)^ @ ap (fun ef => ef oE f^-1) h @ ecompose_1e _). Defined.	Definition	emoveL_1V	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_1e", "ecompose_ee_V" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveL_V1 {A B} (e : A <~> B) (f : B <~> A) : f oE e = 1 -> e = f^-1.	Proof. intro h. exact ((ecompose_V_ee _ _)^ @ ap (fun fe => f^-1 oE fe) h @ ecompose_e1 _). Defined.	Definition	emoveL_V1	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_V_ee", "ecompose_e1" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_M1 {A B} (e f : A <~> B) : 1 = e^-1 oE f -> e = f.	Proof. intro h. exact ((ecompose_e1 _)^ @ ap (fun ef => e oE ef) h @ ecompose_e_Ve _ _). Defined.	Definition	emoveR_M1	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_e1", "ecompose_e_Ve" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_1M {A B} (e f : A <~> B) : 1 = f oE e^-1 -> e = f.	Proof. intro h. exact ((ecompose_1e _)^ @ ap (fun fe => fe oE e) h @ ecompose_eV_e _ _). Defined.	Definition	emoveR_1M	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_1e", "ecompose_eV_e" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_1V {A B} (e : A <~> B) (f : B <~> A) : 1 = f oE e -> e^-1 = f.	Proof. intro h. exact ((ecompose_1e _)^ @ ap (fun fe => fe oE e^-1) h @ ecompose_ee_V _ _). Defined.	Definition	emoveR_1V	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_1e", "ecompose_ee_V" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
emoveR_V1 {A B} (e : A <~> B) (f : B <~> A) : 1 = e oE f -> e^-1 = f.	Proof. intro h. exact ((ecompose_e1 _)^ @ ap (fun ef => e^-1 oE ef) h @ ecompose_V_ee _ _). Defined.	Definition	emoveR_V1	Root	theories/EquivGroupoids.v	[ "Basics.Overture", "Basics.Equivalences", "Types.Equiv" ]	[ "ap", "ecompose_V_ee", "ecompose_e1" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ExcludedMiddle : Type0.		Axiom	ExcludedMiddle	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "Type0" ]	* The law of excluded middle	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
is_global_axiom_excludedmiddle : IsGlobalAxiom ExcludedMiddle	:= {}.	Instance	is_global_axiom_excludedmiddle	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "ExcludedMiddle", "IsGlobalAxiom" ]	Mark this axiom as a "global axiom", which some of our tactics will automatically handle.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
LEM : forall `{ExcludedMiddle} (P : Type), IsHProp P -> P + ~P.		Axiom	LEM	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "ExcludedMiddle", "IsHProp" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ExcludedMiddle_type	:= forall (P : Type), IsHProp P -> P + ~P.	Definition	ExcludedMiddle_type	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "IsHProp" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
decidable_lem `{ExcludedMiddle} (P : Type) `{IsHProp P} : Decidable P	:= LEM P _.	Instance	decidable_lem	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "Decidable", "ExcludedMiddle", "IsHProp", "LEM" ]	** LEM means that all propositions are decidable	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
DNE_type	:= forall P, IsHProp P -> ~~P -> P.	Definition	DNE_type	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "IsHProp" ]	** Double-negation elimination	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
LEM_to_DNE : ExcludedMiddle -> DNE_type.	Proof. intros lem P hp nnp. case (LEM P _). - auto. - intros np; elim (nnp np). Defined.	Definition	LEM_to_DNE	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "DNE_type", "ExcludedMiddle", "LEM", "case" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
DNE_to_LEM `{Funext} : DNE_type -> ExcludedMiddle_type.	Proof. intros dn P hp. refine (dn (P + ~P) _ _). - apply ishprop_sum. + exact _. + exact _. + intros p np; exact (np p). - intros nlem. apply nlem. apply inr. intros p. apply nlem. apply inl. exact p. Defined.	Definition	DNE_to_LEM	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "DNE_type", "ExcludedMiddle_type", "Funext", "inl", "inr", "ishprop_sum" ]	This direction requires Funext.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
allneg_from_DNE (H : DNE_type) (P : Type) `{IsHProp P} : {Q : Type & P <-> ~Q}.	Proof. exists (~P); split. - intros p np; exact (np p). - apply H; exact _. Defined.	Definition	allneg_from_DNE	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "DNE_type", "IsHProp" ]	DNE is equivalent to "every proposition is a negation".	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
DNE_from_allneg (H : forall P, IsHProp P -> {Q : Type & P <-> ~Q}) : DNE_type.	Proof. intros P ? nnp. destruct (H P _) as [Q e]. apply e. intros q. apply nnp. intros p. exact (fst e p q). Defined.	Definition	DNE_from_allneg	Root	theories/ExcludedMiddle.v	[ "HoTT.Basics", "HoTT.Types" ]	[ "DNE_type", "IsHProp", "fst" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ExtensionAlong@{a b p m} {A : Type@{a}} {B : Type@{b}} (f : A -> B) (P : B -> Type@{p}) (d : forall x:A, P (f x))	:= (* { s : forall y:B, P y & forall x:A, s (f x) = d x }. *) sig@{m m} (fun (s : forall y:B, P y) => forall x:A, s (f x) = d x).	Definition	ExtensionAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "sig" ]	This elimination rule (and others) can be seen as saying that, given a fibration over the codomain and a section of it over the domain, there is some extension of this to a section over the whole codomain. It can also be considered as an equivalent form of an [hfiber] of precomposition-with-[f] that replaces paths b...	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
lift_extensionalong@{a1 a2 amin b1 b2 bmin p1 p2 pmin m1 m2} {A : Type@{amin}} {B : Type@{bmin}} (f : A -> B) (P : B -> Type@{pmin}) (d : forall x:A, P (f x)) : ExtensionAlong@{a1 b1 p1 m1} f P d -> ExtensionAlong@{a2 b2 p2 m2} f P d.	Proof. intros ext. (** If we just give [ext], it will collapse the universes. (Anyone stepping through this proof should do [Set Printing Universes] and look at the universes to see that they're different in [ext] and in the goal.) So we decompose [ext] into two components and give them separately. *) ass...	Definition	lift_extensionalong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "m1", "m2" ]	It's occasionally useful to be able to modify those universes. For each of the universes [a], [b], [p], we give an initial one, a final one, and a "minimum" one smaller than both and where the type actually lives.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
equiv_path_extension `{Funext} {A B : Type} {f : A -> B} {P : B -> Type} {d : forall x:A, P (f x)} (ext ext' : ExtensionAlong f P d) : (ExtensionAlong f (fun y => pr1 ext y = pr1 ext' y) (fun x => pr2 ext x @ (pr2 ext' x)^)) <~> ext = ext'.	Proof. revert ext'. srapply equiv_path_from_contr. { unfold ExtensionAlong; cbn. exists (fun y => 1%path). intros x; symmetry; apply concat_pV. } destruct ext as [g gd]; unfold ExtensionAlong; cbn. refine (contr_sigma_sigma (forall y:B, P y) (fun s => forall x:A, s (f x) = ...	Definition	equiv_path_extension	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "Funext", "concat_pV", "contr_equiv'", "contr_sigma_sigma", "equiv_functor_forall_id", "equiv_functor_sigma_id", "equiv_moveR_1M", "equiv_path_from_contr", "equiv_path_inverse", "path", "pr1", "pr2" ]	We called it [lift_extensionalong], but in fact it doesn't require the new universes to be bigger than the old ones, only that they both satisfy the max condition.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
path_extension `{Funext} {A B : Type} {f : A -> B} {P : B -> Type} {d : forall x:A, P (f x)} (ext ext' : ExtensionAlong f P d) : (ExtensionAlong f (fun y => pr1 ext y = pr1 ext' y) (fun x => pr2 ext x @ (pr2 ext' x)^)) -> ext = ext'	:= equiv_path_extension ext ext'.	Definition	path_extension	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "Funext", "equiv_path_extension", "pr1", "pr2" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
isequiv_path_extension `{Funext} {A B : Type} {f : A -> B} {P : B -> Type} {d : forall x:A, P (f x)} (ext ext' : ExtensionAlong f P d) : IsEquiv (path_extension ext ext') \| 0	:= equiv_isequiv _.	Instance	isequiv_path_extension	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "Funext", "IsEquiv", "path_extension" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ExtendableAlong@{i j k l} (n : nat) {A : Type@{i}} {B : Type@{j}} (f : A -> B) (C : B -> Type@{k}) : Type@{l}	:= match n with \| 0 => Unit \| S n => (forall (g : forall a, C (f a)), ExtensionAlong@{i j k l} f C g) * forall (h k : forall b, C b), ExtendableAlong n f (fun b => h b = k b) end.	Fixpoint	ExtendableAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "Unit", "nat" ]	Here is the iterated version.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
lift_extendablealong@{a1 a2 amin b1 b2 bmin p1 p2 pmin m1 m2} (n : nat) {A : Type@{amin}} {B : Type@{bmin}} (f : A -> B) (P : B -> Type@{pmin}) : ExtendableAlong@{a1 b1 p1 m1} n f P -> ExtendableAlong@{a2 b2 p2 m2} n f P.	Proof. revert P; simple_induction n n IH; intros P. - intros _; exact tt. - intros ext; split. + intros g; exact (lift_extensionalong@{a1 a2 amin b1 b2 bmin p1 p2 pmin m1 m2} _ _ _ (fst ext g)). + intros h k. (** Unless we give the universe explicitly here, [kmin] gets collapsed to [k1]...	Definition	lift_extendablealong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "fst", "lift_extensionalong", "m1", "m2", "nat", "simple_induction", "snd" ]	We can modify the universes, as with [ExtensionAlong].	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
equiv_extendable_pathsplit `{Funext} (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) : ExtendableAlong n f C <~> PathSplit n (fun (g : forall b, C b) => g oD f).	Proof. generalize dependent C; simple_induction n n IHn; intros C. 1:exact equiv_idmap. refine (_ *E _); simpl. - refine (equiv_functor_forall' 1 _); intros g; simpl. refine (equiv_functor_sigma' 1 _); intros rec. apply equiv_path_forall. - refine (equiv_functor_forall' 1 _); intros h. ...	Definition	equiv_extendable_pathsplit	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "Funext", "PathSplit", "equiv_apD10", "equiv_functor_forall'", "equiv_functor_pathsplit", "equiv_functor_sigma'", "equiv_idmap", "equiv_inverse", "equiv_path_forall", "nat", "simple_induction" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
isequiv_extendable `{Funext} (n : nat) {A B : Type} {C : B -> Type} {f : A -> B} : ExtendableAlong n.+2 f C -> IsEquiv (fun g => g oD f)	:= isequiv_pathsplit n o (equiv_extendable_pathsplit n.+2 C f).	Definition	isequiv_extendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "Funext", "IsEquiv", "equiv_extendable_pathsplit", "isequiv_pathsplit", "nat" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ishprop_extendable `{Funext} (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) : IsHProp (ExtendableAlong n.+2 f C).	Proof. exact (istrunc_equiv_istrunc _ (equiv_extendable_pathsplit n.+2 C f)^-1). Defined.	Instance	ishprop_extendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "Funext", "IsHProp", "equiv_extendable_pathsplit", "istrunc_equiv_istrunc", "nat" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
equiv_extendable_isequiv `{Funext} (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) : ExtendableAlong n.+2 f C <~> IsEquiv (fun (g : forall b, C b) => g oD f).	Proof. etransitivity. - apply equiv_extendable_pathsplit. - apply equiv_pathsplit_isequiv. Defined.	Definition	equiv_extendable_isequiv	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "Funext", "IsEquiv", "equiv_extendable_pathsplit", "equiv_pathsplit_isequiv", "nat" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_isequiv_precompose {A : Type} {B : Type} (f : A -> B) (C : B -> Type) : IsEquiv (fun (g : forall b, C b) => g oD f) -> forall g, ExtensionAlong f C g.	Proof. intros E g. pose (e := Build_Equiv _ _ _ E). exists (e^-1 g). apply apD10. exact (eisretr e g). Defined.	Definition	extension_isequiv_precompose	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "IsEquiv", "apD10" ]	Without [Funext], we can prove a small part of the above equivalence. We suspect that the rest requires [Funext].	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_postcompose' (n : nat) {A B : Type} (C D : B -> Type) (f : A -> B) (g : forall b, C b <~> D b) : ExtendableAlong n f C -> ExtendableAlong n f D.	Proof. generalize dependent C; revert D. simple_induction n n IH; intros C D g; simpl. 1:exact idmap. refine (functor_prod _ _). - refine (functor_forall (functor_forall idmap (fun a => (g (f a))^-1)) _); intros h; simpl. refine (functor_sigma...	Definition	extendable_postcompose'	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "composeD", "equiv_ap", "equiv_inverse", "functor_arrow", "functor_forall", "functor_prod", "functor_sigma", "idmap", "moveR_equiv_M", "nat", "simple_induction" ]	Postcomposition with a known equivalence. Note that this does not require funext to define, although showing that it is an equivalence would require funext.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_postcompose (n : nat) {A B : Type} (C D : B -> Type) (f : A -> B) (g : forall b, C b -> D b) `{forall b, IsEquiv (g b)} : ExtendableAlong n f C -> ExtendableAlong n f D	:= extendable_postcompose' n C D f (fun b => Build_Equiv _ _ (g b) _).	Definition	extendable_postcompose	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "IsEquiv", "extendable_postcompose'", "nat" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_compose (n : nat) {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ExtendableAlong n g P -> ExtendableAlong n f (fun b => P (g b)) -> ExtendableAlong n (g o f) P.	Proof. revert P; simple_induction n n IHn; intros P extg extf; [ exact tt \| split ]. - intros h. exists ((fst extg (fst extf h).1).1); intros a. refine ((fst extg (fst extf h).1).2 (f a) @ _). exact ((fst extf h).2 a). - intros h k. apply IHn. + exact (snd extg h k). + ex...	Definition	extendable_compose	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "fst", "nat", "simple_induction", "snd" ]	Composition of the maps we extend along. This also does not require funext.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cancelL_extendable (n : nat) {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ExtendableAlong n g P -> ExtendableAlong n (g o f) P -> ExtendableAlong n f (fun b => P (g b)).	Proof. revert P; simple_induction n n IHn; intros P extg extgf; [ exact tt \| split ]. - intros h. exists ((fst extgf h).1 oD g); intros a. exact ((fst extgf h).2 a). - intros h k. pose (h' := (fst extg h).1). pose (k' := (fst extg k).1). refine (extendable_postcompose' n (fun b...	Definition	cancelL_extendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "equiv_concat_lr", "extendable_postcompose'", "fst", "nat", "simple_induction", "snd" ]	And cancellation	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cancelR_extendable (n : nat) {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ExtendableAlong n.+1 f (fun b => P (g b)) -> ExtendableAlong n (g o f) P -> ExtendableAlong n g P.	Proof. revert P; simple_induction n n IHn; intros P extf extgf; [ exact tt \| split ]. - intros h. exists ((fst extgf (h oD f)).1); intros b. refine ((fst (snd extf ((fst extgf (h oD f)).1 oD g) h) _).1 b); intros a. apply ((fst extgf (h oD f)).2). - intros h k. apply IHn. + exa...	Definition	cancelR_extendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "fst", "nat", "simple_induction", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_homotopic (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) {g : A -> B} (p : f == g) : ExtendableAlong n f C -> ExtendableAlong n g C.	Proof. revert C; simple_induction n n IHn; intros C extf; [ exact tt \| split ]. - intros h. exists ((fst extf (fun a => (p a)^ # h a)).1); intros a. refine ((apD ((fst extf (fun a => (p a)^ # h a)).1) (p a))^ @ _). apply moveR_transport_p. exact ((fst extf (fun a => (p a)^ # h a)).2 a). ...	Definition	extendable_homotopic	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "apD", "fst", "moveR_transport_p", "nat", "simple_induction", "snd" ]	And transfer across homotopies	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_equiv (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) `{IsEquiv _ _ f} : ExtendableAlong n f C.	Proof. revert C; simple_induction n n IHn; intros C; [ exact tt \| split ]. - intros h. exists (fun b => eisretr f b # h (f^-1 b)); intros a. refine (transport2 C (eisadj f a) _ @ _). refine ((transport_compose C f _ _)^ @ _). exact (apD h (eissect f a)). - intros h k. apply IHn...	Definition	extendable_equiv	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "IsEquiv", "apD", "nat", "simple_induction", "transport2", "transport_compose" ]	We can extend along equivalences	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_contr (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) `{forall b, Contr (C b)} : ExtendableAlong n f C.	Proof. generalize dependent C; simple_induction n n IHn; intros C ?; [ exact tt \| split ]. - intros h. exists (fun _ => center _); intros a. apply contr. - intros h k. apply IHn; exact _. Defined.	Definition	extendable_contr	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Contr", "ExtendableAlong", "center", "contr", "nat", "simple_induction" ]	And into contractible types	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_homotopy (n : nat) {A B : Type} (C : B -> Type) (f : A -> B) (h k : forall b, C b) : ExtendableAlong n.+1 f C -> ExtendableAlong n f (fun b => h b = k b).	Proof. revert C h k; simple_induction n n IHn; intros C h k ext; [exact tt \| split]. - intros p. exact (fst (snd ext h k) p). - intros p q. apply IHn, ext. Defined.	Definition	extendable_homotopy	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "fst", "nat", "simple_induction", "snd" ]	This is inherited by types of homotopies.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooExtendableAlong@{i j k l} {A : Type@{i}} {B : Type@{j}} (f : A -> B) (C : B -> Type@{k}) : Type@{l}	:= forall n : nat, ExtendableAlong@{i j k l} n f C.	Definition	ooExtendableAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "nat" ]	And the oo-version.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
lift_ooextendablealong@{a1 a2 amin b1 b2 bmin p1 p2 pmin m1 m2} {A : Type@{amin}} {B : Type@{bmin}} (f : A -> B) (P : B -> Type@{pmin}) : ooExtendableAlong@{a1 b1 p1 m1} f P -> ooExtendableAlong@{a2 b2 p2 m2} f P	:= fun ext n => lift_extendablealong@{a1 a2 amin b1 b2 bmin p1 p2 pmin m1 m2} n f P (ext n).	Definition	lift_ooextendablealong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "lift_extendablealong", "m1", "m2", "ooExtendableAlong" ]	Universe modification.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
isequiv_ooextendable `{Funext} {A B : Type} (C : B -> Type) (f : A -> B) : ooExtendableAlong f C -> IsEquiv (fun g => g oD f)	:= fun ps => isequiv_extendable 0 (fst (ps 1%nat), snd (ps 2)).	Definition	isequiv_ooextendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Funext", "IsEquiv", "fst", "isequiv_extendable", "nat", "ooExtendableAlong", "snd" ]	We take part of the data from [ps 1] and part from [ps 2] so that the inverse chosen is the expected one.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
equiv_ooextendable_pathsplit `{Funext} {A B : Type} (C : B -> Type) (f : A -> B) : ooExtendableAlong f C <~> ooPathSplit (fun (g : forall b, C b) => g oD f).	Proof. refine (equiv_functor_forall' 1 _); intros n. apply equiv_extendable_pathsplit. Defined.	Definition	equiv_ooextendable_pathsplit	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Funext", "equiv_extendable_pathsplit", "equiv_functor_forall'", "ooExtendableAlong", "ooPathSplit" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ishprop_ooextendable `{Funext} {A B : Type} (C : B -> Type) (f : A -> B) : IsHProp (ooExtendableAlong f C).	Proof. exact (istrunc_equiv_istrunc _ (equiv_ooextendable_pathsplit C f)^-1). Defined.	Instance	ishprop_ooextendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Funext", "IsHProp", "equiv_ooextendable_pathsplit", "istrunc_equiv_istrunc", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
equiv_ooextendable_isequiv `{Funext} {A B : Type} (C : B -> Type) (f : A -> B) : ooExtendableAlong f C <~> IsEquiv (fun (g : forall b, C b) => g oD f)	:= equiv_oopathsplit_isequiv _ oE equiv_ooextendable_pathsplit _ _.	Definition	equiv_ooextendable_isequiv	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Funext", "IsEquiv", "equiv_ooextendable_pathsplit", "equiv_oopathsplit_isequiv", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_postcompose {A B : Type} (C D : B -> Type) (f : A -> B) (g : forall b, C b -> D b) `{forall b, IsEquiv (g b)} : ooExtendableAlong f C -> ooExtendableAlong f D	:= fun ppp n => extendable_postcompose n C D f g (ppp n).	Definition	ooextendable_postcompose	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "IsEquiv", "extendable_postcompose", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_postcompose' {A B : Type} (C D : B -> Type) (f : A -> B) (g : forall b, C b <~> D b) : ooExtendableAlong f C -> ooExtendableAlong f D	:= fun ppp n => extendable_postcompose' n C D f g (ppp n).	Definition	ooextendable_postcompose'	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_postcompose'", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_compose {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ooExtendableAlong g P -> ooExtendableAlong f (fun b => P (g b)) -> ooExtendableAlong (g o f) P	:= fun extg extf n => extendable_compose n P f g (extg n) (extf n).	Definition	ooextendable_compose	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_compose", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cancelL_ooextendable {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ooExtendableAlong g P -> ooExtendableAlong (g o f) P -> ooExtendableAlong f (fun b => P (g b))	:= fun extg extgf n => cancelL_extendable n P f g (extg n) (extgf n).	Definition	cancelL_ooextendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "cancelL_extendable", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cancelR_ooextendable {A B C : Type} (P : C -> Type) (f : A -> B) (g : B -> C) : ooExtendableAlong f (fun b => P (g b)) -> ooExtendableAlong (g o f) P -> ooExtendableAlong g P	:= fun extf extgf n => cancelR_extendable n P f g (extf n.+1) (extgf n).	Definition	cancelR_ooextendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "cancelR_extendable", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_homotopic {A B : Type} (C : B -> Type) (f : A -> B) {g : A -> B} (p : f == g) : ooExtendableAlong f C -> ooExtendableAlong g C	:= fun extf n => extendable_homotopic n C f p (extf n).	Definition	ooextendable_homotopic	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_homotopic", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_equiv {A B : Type} (C : B -> Type) (f : A -> B) `{IsEquiv _ _ f} : ooExtendableAlong f C	:= fun n => extendable_equiv n C f.	Definition	ooextendable_equiv	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "IsEquiv", "extendable_equiv", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_contr {A B : Type} (C : B -> Type) (f : A -> B) `{forall b, Contr (C b)} : ooExtendableAlong f C	:= fun n => extendable_contr n C f.	Definition	ooextendable_contr	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Contr", "extendable_contr", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_homotopy {A B : Type} (C : B -> Type) (f : A -> B) (h k : forall b, C b) : ooExtendableAlong f C -> ooExtendableAlong f (fun b => h b = k b).	Proof. intros ext n; apply extendable_homotopy, ext. Defined.	Definition	ooextendable_homotopy	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_homotopy", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_isnull_fibers {A B} (f : A -> B) (C : B -> Type) : (forall b, ooExtendableAlong (const_tt (hfiber f b)) (fun _ => C b)) -> ooExtendableAlong f C.	Proof. intros orth n; revert C orth. induction n as [\|n IHn]; intros C orth; [exact tt \| split]. - intros g. exists (fun b => (fst (orth b 1%nat) (fun x => x.2 # g x.1)).1 tt). intros a. rewrite (path_unit tt (const_tt _ a)). exact ((fst (orth (f a) 1%nat) _).2 (a ; 1)). - intros...	Definition	ooextendable_isnull_fibers	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "const_tt", "fst", "hfiber", "induction", "nat", "ooExtendableAlong", "ooextendable_homotopy", "path_unit" ]	Extendability of a family [C] along a map [f] can be detected by extendability of the constant family [C b] along the projection from the corresponding fiber of [f] to [Unit]. Note that this is not an if-and-only-if; the hypothesis can be genuinely stronger than the conclusion.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_extension {A B} (f : A -> B) (C : Cyl f -> Type) (g : forall a, C (cyl a)) (ext : ExtensionAlong cyl C g) : ExtensionAlong cyl C g.	Proof. srefine (Cyl_ind C g (ext.1 o cyr) _ ; _); intros a. + refine ((ext.2 a)^ @Dl _)%dpath. apply apD. + reflexivity. (** The point is that this equality is now definitional. *) Defined.	Definition	cyl_extension	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Cyl", "Cyl_ind", "ExtensionAlong", "apD", "cyl", "cyr" ]	If a family is extendable along a cofibration (i.e. a mapping cylinder), it is extendable definitionally.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_extendable (n : nat) {A B} (f : A -> B) (C : Cyl f -> Type) (ext : ExtendableAlong n cyl C) : ExtendableAlong n cyl C.	Proof. revert C ext; simple_induction n n IH; intros C ext; [ exact tt \| split ]. - intros g. apply cyl_extension. exact (fst ext g). - intros h k; apply IH. exact (snd ext h k). Defined.	Definition	cyl_extendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Cyl", "ExtendableAlong", "cyl", "cyl_extension", "fst", "nat", "simple_induction", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_ooextendable {A B} (f : A -> B) (C : Cyl f -> Type) (ext : ooExtendableAlong cyl C) : ooExtendableAlong cyl C	:= fun n => cyl_extendable n f C (ext n).	Definition	cyl_ooextendable	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "Cyl", "cyl", "cyl_extendable", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_extension' {A B} (f : A -> B) (C : B -> Type) (g : forall a, C (pr_cyl (cyl a))) (ext : ExtensionAlong f C g) : ExtensionAlong cyl (C o pr_cyl) g.	Proof. rapply cyl_extension. exists (ext.1 o pr_cyl). intros x; apply ext.2. Defined.	Definition	cyl_extension'	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtensionAlong", "cyl", "cyl_extension", "pr_cyl" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_extendable' (n : nat) {A B} (f : A -> B) (C : B -> Type) (ext : ExtendableAlong n f C) : ExtendableAlong n cyl (C o (pr_cyl' f)).	Proof. rapply cyl_extendable. refine (cancelL_extendable n C cyl pr_cyl _ ext). rapply extendable_equiv. Defined.	Definition	cyl_extendable'	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "cancelL_extendable", "cyl", "cyl_extendable", "extendable_equiv", "nat", "pr_cyl", "pr_cyl'" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
cyl_ooextendable' {A B} (f : A -> B) (C : B -> Type) (ext : ooExtendableAlong f C) : ooExtendableAlong cyl (C o (pr_cyl' f))	:= fun n => cyl_extendable' n f C (ext n).	Definition	cyl_ooextendable'	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "cyl", "cyl_extendable'", "ooExtendableAlong", "pr_cyl'" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_functor_prod {A B A' B'} (f : A -> A') (g : B -> B') (P : A' * B' -> Type) (ef : forall b', ExtendableAlong 1 f (fun a' => P (a',b'))) (eg : forall a', ExtendableAlong 1 g (fun b' => P (a',b'))) (s : forall z, P (functor_prod f g z)) : ExtensionAlong (f...	Proof. srefine (_;_). - intros [a' b']; revert b'. refine ((fst (eg a') _).1). intros b; revert a'. refine ((fst (ef (g b)) _).1). intros a. exact (s (a,b)). - intros [a b]; cbn. refine ((fst (eg (f a)) _).2 b @ _). exact ((fst (ef (g b)) _).2 a). Defined.	Definition	extension_functor_prod	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "ExtendableAlong", "ExtensionAlong", "fst", "functor_prod" ]	** Extendability along [functor_prod]	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_functor_prod (n : nat) {A B A' B'} (f : A -> A') (g : B -> B') (P : A' * B' -> Type) (ef : forall b', ExtendableAlong n f (fun a' => P (a',b'))) (eg : forall a', ExtendableAlong n g (fun b' => P (a',b'))) : ExtendableAlong n (functor_prod f g) P.	Proof. revert P ef eg; simple_induction n n IH; intros P ef eg; [ exact tt \| split ]. - apply extension_functor_prod. + intros b'; exact (fst (ef b'), fun _ _ => tt). + intros a'; exact (fst (eg a'), fun _ _ => tt). - intros h k; apply IH. + intros b'; apply (snd (ef b')). + intros a'; apply (snd ...	Definition	extendable_functor_prod	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "ExtendableAlong", "extension_functor_prod", "fst", "functor_prod", "nat", "simple_induction", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_functor_prod {A B A' B'} (f : A -> A') (g : B -> B') (P : A' * B' -> Type) (ef : forall b', ooExtendableAlong f (fun a' => P (a',b'))) (eg : forall a', ooExtendableAlong g (fun b' => P (a',b'))) : ooExtendableAlong (functor_prod f g) P	:= fun n => extendable_functor_prod n f g P (fun b' => ef b' n) (fun a' => eg a' n).	Definition	ooextendable_functor_prod	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "extendable_functor_prod", "functor_prod", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_functor_sigma_id {A} {P Q : A -> Type} (f : forall a, P a -> Q a) (C : sig Q -> Type) (ef : forall a, ExtendableAlong 1 (f a) (fun v => C (a;v))) (s : forall z, C (functor_sigma idmap f z)) : ExtensionAlong (functor_sigma idmap f) C s.	Proof. srefine (_;_). - intros [a v]; revert v. refine ((fst (ef a) _).1). intros u. exact (s (a;u)). - intros [a u]; cbn. exact ((fst (ef a) _).2 u). Defined.	Definition	extension_functor_sigma_id	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "ExtensionAlong", "fst", "functor_sigma", "idmap", "sig" ]	** Extendability along [functor_sigma]	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_functor_sigma_id n {A} {P Q : A -> Type} (f : forall a, P a -> Q a) (C : sig Q -> Type) (ef : forall a, ExtendableAlong n (f a) (fun v => C (a;v))) : ExtendableAlong n (functor_sigma idmap f) C.	Proof. revert C ef; simple_induction n n IH; intros C ef; [ exact tt \| split ]. - apply extension_functor_sigma_id. intros a; exact (fst (ef a) , fun _ _ => tt). - intros h k; apply IH. intros a; apply (snd (ef a)). Defined.	Definition	extendable_functor_sigma_id	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "extension_functor_sigma_id", "fst", "functor_sigma", "idmap", "sig", "simple_induction", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_functor_sigma_id {A} {P Q : A -> Type} (f : forall a, P a -> Q a) (C : sig Q -> Type) (ef : forall a, ooExtendableAlong (f a) (fun v => C (a;v))) : ooExtendableAlong (functor_sigma idmap f) C	:= fun n => extendable_functor_sigma_id n f C (fun a => ef a n).	Definition	ooextendable_functor_sigma_id	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_functor_sigma_id", "functor_sigma", "idmap", "ooExtendableAlong", "sig" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
HomotopyExtensionAlong {A B} {Q : B -> Type} (f : A -> B) (C : sig Q -> Type) (p : forall (a:A) (v:Q (f a)), C (f a;v))	:= { q : forall (b:B) (v:Q b), C (b;v) & forall a v, q (f a) v = p a v }.	Definition	HomotopyExtensionAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "sig" ]	Unfortunately, the technology of [ExtensionAlong] seems to be insufficient to state a general, funext-free version of [extension_functor_sigma] with a non-identity map on the bases; the hypothesis on the fiberwise map would have to be the existence of an extension in a function-type "up to pointwise equality". With wi...	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
HomotopyExtendableAlong (n : nat) {A B} {Q : B -> Type} (f : A -> B) (C : sig Q -> Type) : Type	:= match n with \| 0 => Unit \| S n => ((forall (p : forall (a:A) (v:Q (f a)), C (f a;v)), HomotopyExtensionAlong f C p) * (forall (h k : forall z, C z), HomotopyExtendableAlong n f (fun z => h z = k z))) end.	Fixpoint	HomotopyExtendableAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "HomotopyExtensionAlong", "Unit", "nat", "sig" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooHomotopyExtendableAlong {A B} {Q : B -> Type} (f : A -> B) (C : sig Q -> Type)	:= forall n, HomotopyExtendableAlong n f C.	Definition	ooHomotopyExtendableAlong	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "HomotopyExtendableAlong", "sig" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_functor_sigma {A B} {P : A -> Type} {Q : B -> Type} (f : A -> B) (g : forall a, P a -> Q (f a)) (C : sig Q -> Type) (ef : HomotopyExtendableAlong 1 f C) (eg : forall a, ExtendableAlong 1 (g a) (fun v => C (f a ; v))) (s : forall z, C (functor_s...	Proof. srefine (_;_). - intros [b v]; revert b v. refine ((fst ef _).1). intros a. refine ((fst (eg a) _).1). intros u. exact (s (a;u)). - intros [a u]; cbn. refine ((fst ef _).2 _ _ @ _). exact ((fst (eg a) _).2 u). Defined.	Definition	extension_functor_sigma	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "ExtensionAlong", "HomotopyExtendableAlong", "fst", "functor_sigma", "sig" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_functor_sigma (n : nat) {A B} {P : A -> Type} {Q : B -> Type} (f : A -> B) (g : forall a, P a -> Q (f a)) (C : sig Q -> Type) (ef : HomotopyExtendableAlong n f C) (eg : forall a, ExtendableAlong n (g a) (fun v => C (f a ; v))) : ExtendableAlong n (func...	Proof. revert C ef eg; simple_induction n n IH; intros C ef eg; [ exact tt \| split ]. - apply extension_functor_sigma. + exact (fst ef, fun _ _ => tt). + intros a; exact (fst (eg a) , fun _ _ => tt). - intros h k; apply IH. + exact (snd ef h k). + intros a; apply (snd (eg a)). Defined.	Definition	extendable_functor_sigma	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "ExtendableAlong", "HomotopyExtendableAlong", "extension_functor_sigma", "fst", "functor_sigma", "nat", "sig", "simple_induction", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_functor_sigma {A B} {P : A -> Type} {Q : B -> Type} (f : A -> B) (g : forall a, P a -> Q (f a)) (C : sig Q -> Type) (ef : ooHomotopyExtendableAlong f C) (eg : forall a, ooExtendableAlong (g a) (fun v => C (f a ; v))) : ooExtendableAlong (functor_sigm...	:= fun n => extendable_functor_sigma n f g C (ef n) (fun a => eg a n).	Definition	ooextendable_functor_sigma	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "extendable_functor_sigma", "functor_sigma", "ooExtendableAlong", "ooHomotopyExtendableAlong", "sig" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_functor_sum {A B A' B'} (f : A -> A') (g : B -> B') (P : A' + B' -> Type) (ef : ExtendableAlong 1 f (P o inl)) (eg : ExtendableAlong 1 g (P o inr)) (h : forall z, P (functor_sum f g z)) : ExtensionAlong (functor_sum f g) P h.	Proof. srefine (sum_ind _ _ _ ; sum_ind _ _ _). + exact (fst ef (h o inl)).1. + exact (fst eg (h o inr)).1. + exact (fst ef (h o inl)).2. + exact (fst eg (h o inr)).2. Defined.	Definition	extension_functor_sum	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "ExtendableAlong", "ExtensionAlong", "fst", "functor_sum", "inl", "inr", "sum_ind" ]	** Extendability along [functor_sum]	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extendable_functor_sum (n : nat) {A B A' B'} (f : A -> A') (g : B -> B') (P : A' + B' -> Type) (ef : ExtendableAlong n f (P o inl)) (eg : ExtendableAlong n g (P o inr)) : ExtendableAlong n (functor_sum f g) P.	Proof. revert P ef eg; induction n as [\|n IH]; intros P ef eg; [ exact tt \| split ]. - intros h; apply extension_functor_sum. + exact (fst ef, fun _ _ => tt). + exact (fst eg, fun _ _ => tt). - intros h k. apply IH. + exact (snd ef (h o inl) (k o inl)). + exact (snd eg (h o inr) (k o inr)). De...	Definition	extendable_functor_sum	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "ExtendableAlong", "extension_functor_sum", "fst", "functor_sum", "induction", "inl", "inr", "nat", "snd" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
ooextendable_functor_sum {A B A' B'} (f : A -> A') (g : B -> B') (P : A' + B' -> Type) (ef : ooExtendableAlong f (P o inl)) (eg : ooExtendableAlong g (P o inr)) : ooExtendableAlong (functor_sum f g) P.	Proof. intros n; apply extendable_functor_sum; [ apply ef \| apply eg ]. Defined.	Definition	ooextendable_functor_sum	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "extendable_functor_sum", "functor_sum", "inl", "inr", "ooExtendableAlong" ]		https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f
extension_functor_coeq {B A f g B' A' f' g'} {h : B -> B'} {k : A -> A'} {p : k o f == f' o h} {q : k o g == g' o h} {C : Coeq f' g' -> Type} (ek : ExtendableAlong 1 k (C o coeq)) (eh : forall (u v : forall x : B', C (coeq (g' x))), ExtendableAlong 1...	Proof. (** We start by changing the problem to involve [CylCoeq] with cofibrations. *) set (C' := C o pr_cylcoeq p q). set (s' x := pr_cyl_cylcoeq p q x # s x). assert (e : ExtensionAlong (cyl_cylcoeq p q) C' s'). 2:{ pose (ex := fst (extendable_equiv 1 C (pr_cylcoeq p q)) e.1). exists (ex.1); intros x....	Definition	extension_functor_coeq	Root	theories/Extensions.v	[ "HoTT.Basics", "HoTT.Types", "Equiv.PathSplit", "Homotopy.IdentitySystems", "Cubical.DPath", "Cubical.DPathSquare", "Colimits.Coeq", "Colimits.MappingCylinder" ]	[ "A'", "B'", "Coeq", "Coeq_ind", "Coeq_ind_beta_cglue", "Cyl", "DPath", "ExtendableAlong", "ExtensionAlong", "apD", "ap_V", "ap_compose", "ap_cyl_cylcoeq_cglue", "ap_pr_cylcoeq_cglue", "cancelL_extendable", "cglue", "coeq", "cyl", "cyl_cylcoeq", "cyl_extendable", "cyl_extendab...	First we show that if we can extend in [C] along [k], and we can extend in appropriate path-types of [C] along [h], then we can extend in [C] along [functor_coeq]. This is where the hard work is.	https://github.com/HoTT/Coq-HoTT	b75eadc7cb2bc59dca415bf47662a9290f82dc5f

End of preview. Expand in Data Studio

Coq-HoTT

Structured dataset of formalizations from the Coq-HoTT library (Homotopy Type Theory in Coq).

Source

Repository: https://github.com/HoTT/Coq-HoTT
Commit: b75eadc7cb2bc59dca415bf47662a9290f82dc5f
Files: 589
License: bsd-2-clause

Schema

Column	Type	Description
statement	string	Declaration signature/claim with the leading keyword removed (verbatim slice); the full declaration minus its proof
proof	string	Verbatim proof/body, empty if the declaration has none
type	string	Declaration keyword
symbolic_name	string	Declaration identifier
library	string	Sub-library
filename	string	Repository-relative source path
imports	list[string]	File-level `Require`/`Import` modules
deps	list[string]	Intra-corpus identifiers referenced
docstring	string	Preceding documentation comment, empty if absent
source_url	string	Upstream repository
commit	string	Upstream commit extracted

Statistics

Entries: 12,715
With proof: 12,537 (98.6%)
With docstring: 5,206 (40.9%)
Libraries: 92

By type

Type	Count
Definition	6,820
Instance	2,406
Lemma	1,304
Notation	676
Class	371
Ltac	256
Fixpoint	140
Record	139
Coercion	120
Let	105
Theorem	103
Proposition	66
Inductive	48
Axiom	38
Scheme	37
Hypothesis	36
Corollary	26
Example	12
Variant	6
Fact	3
Canonical	1
Parameters	1
Parameter	1

Example

ecompose_e_ee {A B C D} (e : A <~> B) (f : B <~> C) (g : C <~> D)
  : g oE (f oE e) = (g oE f) oE e.
Proof.
    apply path_equiv; reflexivity.
  Defined.

type: Definition | symbolic_name: ecompose_e_ee | theories/EquivGroupoids.v

Use

Each declaration is split into a statement (signature/claim) and a proof (body) that are disjoint and together form the complete declaration, for proof modeling, autoformalization, retrieval, and dependency analysis via deps.

Citation

@misc{coq_hott_dataset,
  title  = {Coq-HoTT},
  author = {Norton, Charles},
  year   = {2026},
  note   = {Extracted from https://github.com/HoTT/Coq-HoTT, commit b75eadc7cb2b},
  url    = {https://huggingface.co/datasets/phanerozoic/Coq-HoTT}
}

Downloads last month: 79

Collection including phanerozoic/Coq-HoTT

Proof Assistant Projects

Collection

Digesting proof assistant libraries for AI ingestion. • 103 items • Updated 5 days ago • 3