Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. β’ 103 items β’ Updated β’ 4
statement stringlengths 7 7.82k | proof stringlengths 0 7.11k | type stringclasses 4
values | symbolic_name stringlengths 1 43 | library stringclasses 37
values | filename stringclasses 238
values | imports listlengths 0 20 | deps listlengths 0 35 | docstring stringclasses 1
value | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
_==_ {i} {A : Type i} (a : A) : A β Type i where
idp : a == a | data | _==_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β€ : Typeβ where
instance constructor unit | record | β€ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Typeβ",
"unit"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Ξ£ {i j} (A : Type i) (B : A β Type j) : Type (lmax i j) where
constructor _,_
field
fst : A
snd : B fst | record | Ξ£ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"fst",
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β₯ : Typeβ where | data | β₯ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Typeβ"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β : Typeβ where
O : β
S : (n : β) β β | data | β | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Typeβ"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Lift {i j} (A : Type i) : Type (lmax i j) where
instance constructor lift
field
lower : A | record | Lift | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"lift"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
TLevel : Typeβ where
β¨-2β© : TLevel
S : (n : TLevel) β TLevel | data | TLevel | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Typeβ",
"β¨-2β©"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Coprod {i j} (A : Type i) (B : Type j) : Type (lmax i j) where
inl : A β Coprod A B
inr : B β Coprod A B | data | Coprod | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Ptd (i : ULevel) : Type (lsucc i) where
constructor β[_,_]
field
deβ : Type i
pt : deβ | record | Ptd | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"deβ",
"pt"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Phantom {i} {A : Type i} (a : A) : Typeβ where
phantom : Phantom a
{-
Numeric literal overloading
This enables writing numeric literals
-} | data | Phantom | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"Typeβ"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
FromNat {i} (A : Type i) : Type (lsucc i) where
field
in-range : β β Type i
read : β n β β¦ _ : in-range n β¦ β A | record | FromNat | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
FromNeg {i} (A : Type i) : Type (lsucc i) where
field
in-range : β β Type i
read : β n β β¦ _ : in-range n β¦ β A | record | FromNeg | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Type : (i : ULevel) β Set (lsucc i) | Type i = Set i | function | Type | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
of-type : β {i} (A : Type i) (u : A) β A | of-type A u = u | function | of-type | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
β¨β© : β {i} {A : Type i} {{a : A}} β A | β¨β© {{a}} = a
{- Identity type
The identity type is called [Path] and [_==_] because the symbol [=] is
reserved in Agda.
The constant path is [idp]. Note that all arguments of [idp] are implicit.
-} | function | β¨β© | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
J : β {i j} {A : Type i} {a : A} (B : (a' : A) (p : a == a') β Type j) (d : B a idp)
{a' : A} (p : a == a') β B a' p | J B d idp = d | function | J | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
J' : β {i j} {A : Type i} {a : A} (B : (a' : A) (p : a' == a) β Type j) (d : B a idp)
{a' : A} (p : a' == a) β B a' p | J' B d idp = d | function | J' | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β_ : β {i} {A : Type i} {x y z : A}
β (x == y β y == z β x == z) | function | _β_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
PathOver : β {i j} {A : Type i} (B : A β Type j)
{x y : A} (p : x == y) (u : B x) (v : B y) β Type j | PathOver B idp u v = (u == v) | function | PathOver | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ap : β {i j} {A : Type i} {B : Type j} (f : A β B) {x y : A}
β (x == y β f x == f y) | ap f idp = idp | function | ap | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
apβ : β {i j k} {A : Type i} {B : A β Type j} {C : A β Type k}
(g : {a : A} β B a β C a) {x y : A} {p : x == y}
{u : B x} {v : B y}
β (u == v [ B β p ] β g u == g v [ C β p ]) | apβ g {p = idp} p = ap g p
{-
[apdβ] is defined in lib.PathOver. Unlike [apβ] and [ap], [apd] is not
definitionally a special case of [apdβ]
-} | function | apβ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"ap",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
apd : β {i j} {A : Type i} {B : A β Type j} (f : (a : A) β B a) {x y : A}
β (p : x == y) β f x == f y [ B β p ] | apd f idp = idp
{-
An equality between types gives two maps back and forth
-} | function | apd | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe : β {i} {A B : Type i} (p : A == B) β A β B | coe idp x = x | function | coe | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe! : β {i} {A B : Type i} (p : A == B) β B β A | coe! idp x = x
{-
The operations of transport forward and backward are defined in terms of [ap]
and [coe], because this is more convenient in practice.
-} | function | coe! | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transport : β {i j} {A : Type i} (B : A β Type j) {x y : A} (p : x == y)
β (B x β B y) | transport B p = coe (ap B p) | function | transport | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"ap",
"coe"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transport! : β {i j} {A : Type i} (B : A β Type j) {x y : A} (p : x == y)
β (B y β B x) | transport! B p = coe! (ap B p)
{- Ξ -types
Shorter notation for Ξ -types.
-} | function | transport! | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"ap",
"coe!"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Ξ : β {i j} (A : Type i) (P : A β Type j) β Type (lmax i j) | Ξ A P = (x : A) β P x
{- Ξ£-types
Ξ£-types are defined as a record so that we have definitional Ξ·.
-} | function | Ξ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
β₯-elim : β {i} {P : β₯ β Type i} β ((x : β₯) β P x) | function | β₯-elim | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Β¬ : β {i} (A : Type i) β Type i | Β¬ A = A β β₯ | function | Β¬ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β _ : β {i} {A : Type i} β (A β A β Type i) | function | _β _ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
idf : β {i} (A : Type i) β (A β A) | idf A = Ξ» x β x | function | idf | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
cst : β {i j} {A : Type i} {B : Type j} (b : B) β (A β B) | cst b = Ξ» _ β b | function | cst | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β_ : β {i j k} {A : Type i} {B : A β Type j} {C : (a : A) β (B a β Type k)}
β (g : {a : A} β Ξ (B a) (C a)) β (f : Ξ A B) β Ξ A (Ξ» a β C a (f a)) | function | _β_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_$_ : β {i j} {A : Type i} {B : A β Type j} β (β x β B x) β (β x β B x) | function | _$_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
curry : β {i j k} {A : Type i} {B : A β Type j} {C : Ξ£ A B β Type k}
β (β s β C s) β (β x y β C (x , y)) | curry f x y = f (x , y) | function | curry | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
uncurry : β {i j k} {A : Type i} {B : A β Type j} {C : β x β B x β Type k}
β (β x y β C x y) β (β s β C (fst s) (snd s)) | uncurry f (x , y) = f x y
{- Truncation levels
The type of truncation levels is isomorphic to the type of natural numbers but
"starts at -2".
-} | function | uncurry | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"fst",
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
β¨_β©ββ : β β βββ | function | β¨_β©ββ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"βββ"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Dec : β {i} (P : Type i) β Type i | Dec P = P β Β¬ P
{-
Pointed types and pointed maps.
[A ββ B] was pointed, but it was never used as a pointed type.
-} | function | Dec | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ptd : β {i} (A : Type i) β A β Ptd i | ptd = β[_,_] | function | ptd | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Ptd",
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_ββ_ : β {i j} β Ptd i β Ptd j β Type (lmax i j) | function | _ββ_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Ptd",
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
βidf : β {i} (X : Ptd i) β X ββ X | βidf X = (Ξ» x β x) , idp | function | βidf | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Ptd",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
βcst : β {i j} {X : Ptd i} {Y : Ptd j} β X ββ Y | βcst {Y = Y} = (Ξ» x β pt Y) , idp
{-
Used in a hack to make HITs maybe consistent. This is just a parametrized unit
type (positively)
-} | function | βcst | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Ptd",
"idp",
"pt"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
β-reader : FromNat β | function | β-reader | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"FromNat"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
TLevel-reader : FromNat TLevel | function | TLevel-reader | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"FromNat",
"TLevel"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
TLevel-neg-reader : FromNeg TLevel | function | TLevel-neg-reader | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"FromNeg",
"TLevel"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Typeβ = Type lzero | function | Typeβ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Type0 = Type lzero | function | Type0 | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Typeβ = Type (lsucc lzero) | function | Typeβ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Type1 = Type (lsucc lzero)
{-
There is no built-in or standard way to coerce an ambiguous term to a given type
(like [u : A] in ML), the symbol [:] is reserved, and the Unicode [βΆ] is really
a bad idea.
So weβre using the symbol [_:>_], which has the advantage that it can micmic
Coqβs [u = v :> A].
-} | function | Type1 | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Path = _==_
{-# BUILTIN EQUALITY _==_ #-}
{- Paulin-Mohring J rule
At the time Iβm writing this (July 2013), the identity type is somehow broken in
Agda dev, it behaves more or less as the Martin-LΓΆf identity type instead of
behaving like the Paulin-Mohring identity type.
So here is the Paulin-Mohring J rule -} | function | Path | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"_==_"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
idp β q = q
{- Rewriting
This is a new pragma added to Agda to help create higher inductive types.
-} | function | idp | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Unit = β€
{-# BUILTIN UNIT β€ #-}
{- Dependent paths
The notion of dependent path is a very important notion.
If you have a dependent type [B] over [A], a path [p : x == y] in [A] and two
points [u : B x] and [v : B y], there is a type [u == v [ B β p ]] of paths from
[u] to [v] lying over the path [p].
By definition... | function | Unit | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
pair= : β {i j} {A : Type i} {B : A β Type j}
{a a' : A} (p : a == a') {b : B a} {b' : B a'}
(q : b == b' [ B β p ])
β (a , b) == (a' , b') | pair= idp q = ap (_ ,_) q | function | pair= | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"ap",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
pairΓ= : β {i j} {A : Type i} {B : Type j}
{a a' : A} (p : a == a') {b b' : B} (q : b == b')
β (a , b) == (a' , b') | pairΓ= idp q = pair= idp q
{- Empty type
We define the eliminator of the empty type using an absurd pattern. Given that
absurd patterns are not consistent with HIT, we will not use empty patterns
anymore after that.
-} | function | pairΓ= | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"idp",
"pair="
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Empty = β₯ | function | Empty | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Empty-elim = β₯-elim
{- Negation and disequality -} | function | Empty-elim | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"β₯-elim"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
x β y = Β¬ (x == y)
{- Natural numbers -} | function | x | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
Nat = β
{-# BUILTIN NATURAL β #-}
{- Lifting to a higher universe level
The operation of lifting enjoys both Ξ² and Ξ· definitionally.
Itβs a bit annoying to use, but itβs not used much (for now).
-} | function | Nat | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_=β¨_β©_ : β {i} {A : Type i} (x : A) {y z : A} β x == y β y == z β x == z | function | _=β¨_β©_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_ =β¨ idp β© idp = idp | _ =β = idp | function | _ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_=β : β {i} {A : Type i} (x : A) β x == x | function | _=β | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
g β f = Ξ» x β g (f x)
-- Application | function | g | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
f $ x = f x
-- (Un)curryfication | function | f | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
βββ = TLevel | function | βββ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"TLevel"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β¨ O β©ββ = β¨-2β© | β¨ S n β©ββ = S β¨ n β©ββ
{- Coproducts and case analysis -} | function | β¨ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"β¨-2β©"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β_ = Coprod | function | _β_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Coprod"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
ptd= : β {i} {A A' : Type i} (p : A == A')
{a : A} {a' : A'} (q : a == a' [ idf _ β p ])
β β[ A , a ] == β[ A' , a' ] | ptd= idp q = ap β[ _ ,_] q | function | ptd= | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Type",
"ap",
"idf",
"idp",
"β["
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Ptdβ = Ptd lzero | function | Ptdβ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"Ptd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β[ A , aβ ] ββ β[ B , bβ ] = Ξ£ (A β B) (Ξ» f β f aβ == bβ) | function | _ββ_ | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
FromNat.in-range β-reader _ = β€ | FromNat.in-range TLevel-reader _ = β€ | function | FromNat.in-range | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"TLevel-reader",
"β-reader"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
FromNat.read β-reader n = n | FromNat.read TLevel-reader n = S (S β¨ n β©ββ) | function | FromNat.read | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"TLevel-reader",
"β-reader"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
FromNeg.in-range TLevel-neg-reader O = β€ | FromNeg.in-range TLevel-neg-reader 1 = β€
FromNeg.in-range TLevel-neg-reader 2 = β€
FromNeg.in-range TLevel-neg-reader (S (S (S _))) = β₯ | function | FromNeg.in-range | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"TLevel-neg-reader"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
FromNeg.read TLevel-neg-reader O = S (S β¨-2β©) | FromNeg.read TLevel-neg-reader 1 = S β¨-2β©
FromNeg.read TLevel-neg-reader 2 = β¨-2β© | function | FromNeg.read | core.lib | core/lib/Base.agda | [
"Agda.Primitive"
] | [
"TLevel-neg-reader",
"β¨-2β©"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
htpy-natural : β {i j} {A : Type i} {B : Type j} {x y : A} {f g : A β B}
(p : β x β (f x == g x)) (q : x == y) β ap f q β p y == p x β ap g q | htpy-natural p idp = ! (β-unit-r _) | function | htpy-natural | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ap",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β_ : β {i j} (A : Type i) (B : Type j) β Type (lmax i j) | function | _β_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
idf-is-equiv : β {i} (A : Type i) β is-equiv (idf A) | idf-is-equiv A = record {g = idf A; f-g = (Ξ» _ β idp); g-f = (Ξ» _ β idp); adj = (Ξ» _ β idp)} | function | idf-is-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"idf",
"idp",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ide : β {i} (A : Type i) β A β A | ide A = idf A , idf-is-equiv A | function | ide | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"idf",
"idf-is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transport-equiv : β {i j} {A : Type i} (B : A β Type j) {x y : A} (p : x == y)
β (B x β B y) | transport-equiv B idp = ide _ | function | transport-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ide",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_βe_ : β {i j k} {A : Type i} {B : Type j} {C : Type k}
β B β C β A β B β A β C | function | _βe_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_βise_ : β {i j k} {A : Type i} {B : Type j} {C : Type k}
{f : A β B} {g : B β C}
β is-equiv g β is-equiv f β is-equiv (g β f) | function | _βise_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
is-equiv-inverse : β {i j} {A : Type i} {B : Type j} {f : A β B}
β (f-is-equiv : is-equiv f) β is-equiv (is-equiv.g f-is-equiv) | is-equiv-inverse {f = g} ise = record { g = _ ; M } where
module M where
f = is-equiv.g ise
abstract
f-g : β b β f (g b) == b
f-g = is-equiv.g-f ise
g-f : β a β g (f a) == a
g-f = is-equiv.f-g ise
adj : β a β ap f (g-f a) == f-g (f a)
adj = is-equiv.adj' ise | function | is-equiv-inverse | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ap",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_β»ΒΉ : β {i j} {A : Type i} {B : Type j} β (A β B) β (B β A) | function | _β»ΒΉ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_ββ¨_β©_ : β {i j k} (A : Type i) {B : Type j} {C : Type k} β A β B β B β C β A β C | function | _ββ¨_β©_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_ββ : β {i} (A : Type i) β A β A | _ββ = ide
{- lifting is an equivalence -} | function | _ββ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ide"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
lower-equiv : β {i j} {A : Type i} β Lift {j = j} A β A | lower-equiv = equiv lower lift (Ξ» _ β idp) (Ξ» _ β idp)
{- Any contractible type is equivalent to (all liftings of) the unit type -} | function | lower-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Lift",
"Type",
"idp",
"lift"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
βΌ-preserves-equiv : β {i j} {A : Type i} {B : Type j} {fβ fβ : A β B}
β fβ βΌ fβ β is-equiv fβ β is-equiv fβ | βΌ-preserves-equiv homotopy f-ise =
is-eq _ g (Ξ» b β ! (homotopy (g b)) β f-g b) (Ξ» a β ap g (! (homotopy a)) β g-f a)
where open is-equiv f-ise
{-
Pointed equivalences
-} | function | βΌ-preserves-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ap",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_ββ_ : β {i j} β Ptd i β Ptd j β Type (lmax i j) | function | _ββ_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
β-to-ββ : β {i j} {X : Ptd i} {Y : Ptd j}
(e : deβ X β deβ Y) (p : β> e (pt X) == pt Y)
β X ββ Y | β-to-ββ (f , ie) p = ((f , p) , ie) | function | β-to-ββ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"deβ",
"pt"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
βide : β {i} (X : Ptd i) β (X ββ X) | βide X = βidf X , idf-is-equiv (deβ X) | function | βide | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"deβ",
"idf-is-equiv",
"βidf"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_ββe_ : β {i j k} {X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(g : Y ββ Z) (f : X ββ Y) β X ββ Z | function | _ββe_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_βββ¨_β©_ : β {i j k} (X : Ptd i) {Y : Ptd j} {Z : Ptd k}
β X ββ Y β Y ββ Z β X ββ Z | function | _βββ¨_β©_ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_βββ : β {i} (X : Ptd i) β X ββ X | _βββ = βide | function | _βββ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"βide"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-cs-equiv : β {iβ iβ jβ jβ}
{Aβ : Type iβ} {Aβ : Type iβ} {Bβ : Type jβ} {Bβ : Type jβ}
{fβ : Aβ β Bβ} {fβ : Aβ β Bβ} {hA : Aβ β Aβ} {hB : Bβ β Bβ}
β CommSquare fβ fβ hA hB β Type (lmax (lmax iβ iβ) (lmax jβ jβ)) | is-cs-equiv {hA = hA} {hB} _ = Ξ£ (is-equiv hA) (Ξ» _ β is-equiv hB) | function | is-cs-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"CommSquare",
"Type",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
CommSquareEquiv : β {iβ iβ jβ jβ}
{Aβ : Type iβ} {Aβ : Type iβ} {Bβ : Type jβ} {Bβ : Type jβ}
(fβ : Aβ β Bβ) (fβ : Aβ β Bβ) (hA : Aβ β Aβ) (hB : Bβ β Bβ)
β Type (lmax (lmax iβ iβ) (lmax jβ jβ)) | CommSquareEquiv fβ fβ hA hB = Ξ£ (CommSquare fβ fβ hA hB) is-cs-equiv | function | CommSquareEquiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"CommSquare",
"Type",
"is-cs-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-βcs-equiv : β {iβ iβ jβ jβ}
{Xβ : Ptd iβ} {Xβ : Ptd iβ} {Yβ : Ptd jβ} {Yβ : Ptd jβ}
{fβ : Xβ ββ Yβ} {fβ : Xβ ββ Yβ} {hX : Xβ ββ Xβ} {hY : Yβ ββ Yβ}
β βCommSquare fβ fβ hX hY β Type (lmax (lmax iβ iβ) (lmax jβ jβ)) | is-βcs-equiv {hX = hX} {hY} _ = Ξ£ (is-equiv (fst hX)) (Ξ» _ β is-equiv (fst hY)) | function | is-βcs-equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"Type",
"fst",
"is-equiv",
"βCommSquare"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
βCommSquareEquiv : β {iβ iβ jβ jβ}
{Xβ : Ptd iβ} {Xβ : Ptd iβ} {Yβ : Ptd jβ} {Yβ : Ptd jβ}
(fβ : Xβ ββ Yβ) (fβ : Xβ ββ Yβ) (hX : Xβ ββ Xβ) (hY : Yβ ββ Yβ)
β Type (lmax (lmax iβ iβ) (lmax jβ jβ)) | βCommSquareEquiv fβ fβ hX hY = Ξ£ (βCommSquare fβ fβ hX hY) is-βcs-equiv | function | βCommSquareEquiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Ptd",
"Type",
"is-βcs-equiv",
"βCommSquare"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
htpy-natural-app=idf : β {i} {A : Type i} {f : A β A}
(p : β (x : A) β f x == x) β (β x β ap f (p x) == p (f x)) | htpy-natural-app=idf {f = f} p x = anti-whisker-right (p x) $
htpy-natural p (p x) β ap (p (f x) β_) (ap-idf (p x)) | function | htpy-natural-app=idf | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"Type",
"ap",
"ap-idf",
"htpy-natural"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
A β B = Ξ£ (A β B) is-equiv | A ββ¨ u β© v = v βe u | function | A | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Equiv = _β_ | function | Equiv | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"_β_"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
e1 βe e2 = (β> e1 β β> e2) , record {g = (<β e2 β <β e1); M} where
module M where
f = β> e1 β β> e2
g = <β e2 β <β e1
abstract
f-g : β c β f (g c) == c
f-g c = ap (β> e1) (<β-inv-r e2 (<β e1 c)) β <β-inv-r e1 c
g-f : β a β g (f a) == a
g-f a = ap (<β e2) (<β-inv-l e1 (β> e2 a)) β <... | function | e1 | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"ap",
"ap-idf",
"htpy-natural"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 |
End of preview. Expand in Data Studio
Agda-HoTT
Structured dataset from HoTT-Agda β Homotopy Type Theory.
Source
- Repository: https://github.com/HoTT/HoTT-Agda
- Commit:
1037d82edcf29b620677a311dcfd4fc2ade2faa6 - Files: 420
- License: mit
Schema
| Column | Type | Description |
|---|---|---|
| statement | string | Declaration signature/claim with the leading keyword removed (verbatim slice); the full declaration minus its proof |
| proof | string | Verbatim proof/body, empty if the declaration has none |
| type | string | Declaration keyword |
| symbolic_name | string | Declaration identifier |
| library | string | Sub-library |
| filename | string | Repository-relative source path |
| imports | list[string] | File-level Require/Import modules |
| deps | list[string] | Intra-corpus identifiers referenced |
| docstring | string | Preceding documentation comment, empty if absent |
| source_url | string | Upstream repository |
| commit | string | Upstream commit extracted |
Statistics
- Entries: 2,324
- With proof: 1,901 (81.8%)
- With docstring: 0 (0.0%)
- Libraries: 37
By type
| Type | Count |
|---|---|
| function | 2,196 |
| record | 67 |
| data | 36 |
| postulate | 25 |
Example
β¨β© : β {i} {A : Type i} {{a : A}} β A
β¨β© {{a}} = a
{- Identity type
The identity type is called [Path] and [_==_] because the symbol [=] is
reserved in Agda.
The constant path is [idp]. Note that all arguments of [idp] are implicit.
-}
- type: function | symbolic_name:
β¨β©| core/lib/Base.agda
Use
Each declaration is split into a statement (signature/claim) and a proof (body) that are disjoint
and together form the complete declaration, for proof modeling, autoformalization, retrieval, and
dependency analysis via deps.
Citation
@misc{agda_hott_dataset,
title = {Agda-HoTT},
author = {Norton, Charles},
year = {2026},
note = {Extracted from https://github.com/HoTT/HoTT-Agda, commit 1037d82edcf2},
url = {https://huggingface.co/datasets/phanerozoic/Agda-HoTT}
}
- Downloads last month
- 16