Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion.
•
84 items
•
Updated
•
3
Datasets:
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.
|
End of preview. Expand
in Data Studio
Coq-HoTT
Structured dataset of formalizations from the Coq-HoTT library (Homotopy Type Theory in Coq).
Schema
| Column | Type | Description |
|---|---|---|
| fact | string | Full declaration (name, signature, body) |
| type | string | Definition, Lemma, Theorem, Class, Instance, etc. |
| library | string | Sub-library within HoTT (Basics, Types, Spaces, etc.) |
| imports | list | Require Import statements |
| filename | string | Source file path |
| symbolic_name | string | Declaration identifier |
| docstring | string | Documentation comment (41% coverage) |
Statistics
By Type
| Type | Count |
|---|---|
| Definition | 6,726 |
| Instance | 2,355 |
| Lemma | 1,308 |
| Class | 363 |
| Fixpoint | 141 |
| Record | 139 |
| Theorem | 103 |
| Proposition | 67 |
| Inductive | 39 |
| Other | 292 |
Docstring Coverage
- 4,756 entries (41%) have documentation
Example Entry
Use Cases
- Retrieval / RAG for Coq theorem proving
- Homotopy Type Theory research
- Training embeddings for formal mathematics
- Documentation generation
Citation
Changelog
- v2.0 (Jan 2025): Re-extraction with improved schema
- 7,848 -> 11,533 entries (+47%)
- Added library and docstring columns
- Changed imports from string to list
- Removed index_level column
- fact now includes full signature
- v1.0 (Dec 2024): Initial release
- Downloads last month
- 38
Source:
HoTT/Coq-HoTT
Entries:
11,533
Files processed:
583
License:
BSD 2-Clause
Size of downloaded dataset files:
919 kB
Size of the auto-converted Parquet files:
919 kB
Number of rows:
11,533