fact stringlengths 4 2.87k | type stringclasses 17 values | library stringclasses 91 values | imports listlengths 0 19 | filename stringclasses 497 values | symbolic_name stringlengths 1 75 | docstring stringlengths 5 3.99k ⌀ |
|---|---|---|---|---|---|---|
ecompose_e1 {A B} (e : A <~> B) : e oE 1 = e. | Lemma | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_e1 | The identity equivalence is a right unit. |
ecompose_1e {A B} (e : A <~> B) : 1 oE e = e. | Lemma | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_1e | The identity is a left unit. |
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. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_e_ee | Composition is associative. |
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). | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_ee_e | null |
ecompose_eV {A B} (e : A <~> B) : e oE e^-1 = 1. | Lemma | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_eV | The left inverse law. |
ecompose_Ve {A B} (e : A <~> B) : e^-1 oE e = 1. | Lemma | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_Ve | The right inverse law. |
ecompose_V_ee {A B C} (e : A <~> B) (f : B <~> C)
: f^-1 oE (f oE e) = e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_V_ee | Several auxiliary theorems about canceling inverses across associativity. These are somewhat redundant, following from earlier theorems. |
ecompose_e_Ve {A B C} (e : A <~> B) (f : C <~> B)
: e oE (e^-1 oE f) = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_e_Ve | null |
ecompose_ee_V {A B C} (e : A <~> B) (f : B <~> C)
: (f oE e) oE e^-1 = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_ee_V | null |
ecompose_eV_e {A B C} (e : B <~> A) (f : B <~> C)
: (f oE e^-1) oE e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | ecompose_eV_e | null |
einv_ee {A B C} (e : A <~> B) (f : B <~> C)
: (f oE e)^-1 = e^-1 oE f^-1. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | einv_ee | Inverse distributes over composition |
einv_Ve {A B C} (e : A <~> C) (f : B <~> C)
: (f^-1 oE e)^-1 = e^-1 oE f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | einv_Ve | null |
einv_eV {A B C} (e : C <~> A) (f : C <~> B)
: (f oE e^-1)^-1 = e oE f^-1. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | einv_eV | null |
einv_VV {A B C} (e : A <~> B) (f : B <~> C)
: (e^-1 oE f^-1)^-1 = f oE e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | einv_VV | null |
einv_V {A B} (e : A <~> B)
: (e^-1)^-1 = e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | einv_V | Inverse is an involution. |
emoveR_Me {A B C} (e : B <~> A) (f : B <~> C) (g : A <~> C)
: e = g^-1 oE f -> g oE e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_Me | *** Theorems for moving things around in equations. |
emoveR_eM {A B C} (e : B <~> A) (f : B <~> C) (g : A <~> C)
: g = f oE e^-1 -> g oE e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_eM | null |
emoveR_Ve {A B C} (e : B <~> A) (f : B <~> C) (g : C <~> A)
: e = g oE f -> g^-1 oE e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_Ve | null |
emoveR_eV {A B C} (e : A <~> B) (f : B <~> C) (g : A <~> C)
: g = f oE e -> g oE e^-1 = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_eV | null |
emoveL_Me {A B C} (e : A <~> B) (f : A <~> C) (g : B <~> C)
: g^-1 oE f = e -> f = g oE e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_Me | null |
emoveL_eM {A B C} (e : A <~> B) (f : A <~> C) (g : B <~> C)
: f oE e^-1 = g -> f = g oE e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_eM | null |
emoveL_Ve {A B C} (e : A <~> C) (f : A <~> B) (g : B <~> C)
: g oE f = e -> f = g^-1 oE e. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_Ve | null |
emoveL_eV {A B C} (e : A <~> B) (f : B <~> C) (g : A <~> C)
: f oE e = g -> f = g oE e^-1. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_eV | null |
emoveL_1M {A B} (e f : A <~> B)
: e oE f^-1 = 1 -> e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_1M | null |
emoveL_M1 {A B} (e f : A <~> B)
: f^-1 oE e = 1 -> e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_M1 | null |
emoveL_1V {A B} (e : A <~> B) (f : B <~> A)
: e oE f = 1 -> e = f^-1. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_1V | null |
emoveL_V1 {A B} (e : A <~> B) (f : B <~> A)
: f oE e = 1 -> e = f^-1. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveL_V1 | null |
emoveR_M1 {A B} (e f : A <~> B)
: 1 = e^-1 oE f -> e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_M1 | null |
emoveR_1M {A B} (e f : A <~> B)
: 1 = f oE e^-1 -> e = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_1M | null |
emoveR_1V {A B} (e : A <~> B) (f : B <~> A)
: 1 = f oE e -> e^-1 = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_1V | null |
emoveR_V1 {A B} (e : A <~> B) (f : B <~> A)
: 1 = e oE f -> e^-1 = f. | Definition | Root | [
"Basics"
] | theories/EquivGroupoids.v | emoveR_V1 | null |
Class ExcludedMiddle. | Existing | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | Class | null |
is_global_axiom_excludedmiddle : IsGlobalAxiom ExcludedMiddle := {}. | Instance | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | is_global_axiom_excludedmiddle | Mark this axiom as a "global axiom", which some of our tactics will automatically handle. |
LEM : forall `{ExcludedMiddle} (P : Type), IsHProp P -> P + ~P. | Axiom | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | LEM | null |
ExcludedMiddle_type := forall (P : Type), IsHProp P -> P + ~P. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | ExcludedMiddle_type | null |
decidable_lem `{ExcludedMiddle} (P : Type) `{IsHProp P} : Decidable P
:= LEM P _. | Instance | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | decidable_lem | ** LEM means that all propositions are decidable |
DNE_type := forall P, IsHProp P -> ~~P -> P. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | DNE_type | ** Double-negation elimination |
LEM_to_DNE : ExcludedMiddle -> DNE_type. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | LEM_to_DNE | null |
DNE_to_LEM `{Funext} :
DNE_type -> ExcludedMiddle_type. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | DNE_to_LEM | This direction requires Funext. |
allneg_from_DNE (H : DNE_type) (P : Type) `{IsHProp P}
: {Q : Type & P <-> ~Q}. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | allneg_from_DNE | DNE is equivalent to "every proposition is a negation". |
DNE_from_allneg (H : forall P, IsHProp P -> {Q : Type & P <-> ~Q})
: DNE_type. | Definition | Root | [
"HoTT"
] | theories/ExcludedMiddle.v | DNE_from_allneg | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ExtensionAlong | 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 by pointwise paths, thereby avoiding [Funext]. |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | lift_extensionalong | 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. |
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'. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | equiv_path_extension | 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. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | path_extension | null |
#[export] Instance 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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | isequiv_path_extension | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ExtendableAlong | Here is the iterated version. |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | lift_extendablealong | We can modify the universes, as with [ExtensionAlong]. |
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). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | equiv_extendable_pathsplit | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | isequiv_extendable | null |
#[export] Instance ishprop_extendable `{Funext} (n : nat)
{A B : Type} (C : B -> Type) (f : A -> B)
: IsHProp (ExtendableAlong n.+2 f C). | Instance | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ishprop_extendable | null |
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). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | equiv_extendable_isequiv | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_isequiv_precompose | Unless we give the universe explicitly here, [kmin] gets collapsed to [k1]. |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_postcompose | Postcomposition with a known equivalence. Note that this does not require funext to define, although showing that it is an equivalence would require funext. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_postcompose | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_compose | Composition of the maps we extend along. This also does not require funext. |
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)). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cancelL_extendable | And cancellation |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cancelR_extendable | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_homotopic | And transfer across homotopies |
extendable_equiv (n : nat)
{A B : Type} (C : B -> Type) (f : A -> B) `{IsEquiv _ _ f}
: ExtendableAlong n f C. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_equiv | We can extend along equivalences |
extendable_contr (n : nat)
{A B : Type} (C : B -> Type) (f : A -> B)
`{forall b, Contr (C b)}
: ExtendableAlong n f C. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_contr | And into contractible types |
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). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_homotopy | This is inherited by types of homotopies. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooExtendableAlong | And the oo-version. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | lift_ooextendablealong | Universe modification. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | isequiv_ooextendable | We take part of the data from [ps 1] and part from [ps 2] so that the inverse chosen is the expected one. |
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). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | equiv_ooextendable_pathsplit | null |
#[export] Instance ishprop_ooextendable `{Funext}
{A B : Type} (C : B -> Type) (f : A -> B)
: IsHProp (ooExtendableAlong f C). | Instance | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ishprop_ooextendable | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | equiv_ooextendable_isequiv | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_postcompose | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_postcompose | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_compose | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cancelL_ooextendable | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cancelR_ooextendable | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_homotopic | null |
ooextendable_equiv
{A B : Type} (C : B -> Type) (f : A -> B) `{IsEquiv _ _ f}
: ooExtendableAlong f C
:= fun n => extendable_equiv n C f. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_equiv | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_contr | null |
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). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_homotopy | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_isnull_fibers | 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. |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_extension | If a family is extendable along a cofibration (i.e. a mapping cylinder), it is extendable definitionally. |
cyl_extendable (n : nat)
{A B} (f : A -> B) (C : Cyl f -> Type)
(ext : ExtendableAlong n cyl C)
: ExtendableAlong n cyl C. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_extendable | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_ooextendable | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_extension | null |
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)). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_extendable | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | cyl_ooextendable | null |
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 (functor_prod f g) P s. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_functor_prod | ** Extendability along [functor_prod] |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_functor_prod | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_functor_prod | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_functor_sigma_id | ** Extendability along [functor_sigma] |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_functor_sigma_id | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_functor_sigma_id | null |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | HomotopyExtensionAlong | 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 wild oo-groupoids we could probably manage it. For now, we say something a bit hacky. |
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 | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | HomotopyExtendableAlong | null |
ooHomotopyExtendableAlong
{A B} {Q : B -> Type} (f : A -> B) (C : sig Q -> Type)
:= forall n, HomotopyExtendableAlong n f C. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooHomotopyExtendableAlong | null |
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_sigma f g z))
: ExtensionAlong (functor_sigma f g) C s. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_functor_sigma | null |
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 (functor_sigma f g) C. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_functor_sigma | null |
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_sigma f g) C
:= fun n => extendable_functor_sigma n f g C (ef n) (fun a => eg a n). | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_functor_sigma | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_functor_sum | ** Extendability along [functor_sum] |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extendable_functor_sum | null |
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. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | ooextendable_functor_sum | null |
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 h (fun x => u x = v x))
(s : forall x, C (functor_coeq h k p q x))
: ExtensionAlong (functor_coeq h k p q) C s. | Definition | Root | [
"HoTT",
"Equiv",
"Cubical",
"Colimits"
] | theories/Extensions.v | extension_functor_coeq | 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. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.