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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.