Datasets:

phanerozoic
/

Agda-HoTT

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	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: 12

Collection including phanerozoic/Agda-HoTT

Proof Assistant Projects

Collection

Digesting proof assistant libraries for AI ingestion. • 103 items • Updated Jun 8 • 3