fact stringlengths 5 24.4k | type stringclasses 3
values | library stringclasses 2
values | imports listlengths 0 70 | filename stringlengths 18 57 | symbolic_name stringlengths 1 32 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
_ : is-set A ≡ is-hlevel A 2 | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | _ | |
is-groupoid : ∀ {ℓ} → Type ℓ → Type ℓ | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-groupoid | |
_ : (a : A) → is-contr (Σ[ b ∈ A ] b ≡ a) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | _ | |
Singleton-is-contr : {x : A} → is-contr (Singleton x) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | Singleton-is-contr | |
Singleton'-is-contr : {x : A} → is-contr (Σ[ y ∈ A ] y ≡ x) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | Singleton'-is-contr | |
interval-contractible : is-contr [0,1] | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | interval-contractible | |
Path-is-hlevel' : (n : Nat) → is-hlevel A (suc n) → (x y : A) → is-hlevel (x ≡ y) n | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | Path-is-hlevel' | |
is-hlevel-suc : ∀ {ℓ} {A : Type ℓ} (n : Nat) → is-hlevel A n → is-hlevel A (suc n) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-hlevel-suc | |
is-hlevel-join : ∀ {ℓ} {A : Type ℓ} (n : Nat) → (A → is-hlevel A (suc n)) → is-hlevel A (suc n) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-hlevel-join | |
is-prop-is-prop : is-prop (is-prop A) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-prop-is-prop | |
is-contr-is-prop : is-prop (is-contr A) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-contr-is-prop | |
is-hlevel-is-prop : ∀ {ℓ} {A : Type ℓ} (n : Nat) → is-prop (is-hlevel A n) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-hlevel-is-prop | |
is-hlevel-is-hlevel-suc : ∀ {ℓ} {A : Type ℓ} (k n : Nat) → is-hlevel (is-hlevel A n) (suc k) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-hlevel-is-hlevel-suc | |
is-hlevel-dep : ∀ {ℓ ℓ'} {A : Type ℓ} → (A → Type ℓ') → Nat → Type _ | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | is-hlevel-dep | |
SingletonP : ∀ {ℓ} (A : I → Type ℓ) (a : A i0) → Type _ | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | SingletonP | |
SinglP-is-contr : ∀ {ℓ} (A : I → Type ℓ) (a : A i0) → is-contr (SingletonP A a) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | SinglP-is-contr | |
SinglP-is-prop : ∀ {ℓ} {A : I → Type ℓ} {a : A i0} → is-prop (SingletonP A a) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | SinglP-is-prop | |
Single-is-contr : ∀ {x : A} → is-contr (Singleton x) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | Single-is-contr | |
Single-is-contr' : ∀ {x : A} → is-contr (Σ[ y ∈ A ] y ≡ x) | function | src | [
"open import 1Lab.Path",
"open import 1Lab.Type"
] | src/1Lab/HLevel.lagda.md | Single-is-contr' | |
customtitle : Introduction to HoTT | function | src | [
"open import 1Lab.Prelude hiding (fibre)",
"open import 1Lab.Path",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Equiv.Biinv",
"open import 1Lab.Equiv.HalfAdjoint",
"open import 1Lab.Counterexamples.IsIso",
"open import 1Lab.Univalence",
"open import 1Lab.Univalence.SIP"
] | src/1Lab/intro.lagda.md | customtitle | |
_ : 2 + 2 ≡ 4 | function | src | [
"open import 1Lab.Prelude hiding (fibre)",
"open import 1Lab.Path",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Equiv.Biinv",
"open import 1Lab.Equiv.HalfAdjoint",
"open import 1Lab.Counterexamples.IsIso",
"open import 1Lab.Univalence",
"open import 1Lab.Univalence.SIP"
] | src/1Lab/intro.lagda.md | _ | |
idea : the correspondence between predicates and subsets. Initially, we | function | src | [
"open import 1Lab.Prelude hiding (fibre)",
"open import 1Lab.Path",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Equiv.Biinv",
"open import 1Lab.Equiv.HalfAdjoint",
"open import 1Lab.Counterexamples.IsIso",
"open import 1Lab.Univalence",
"open import 1Lab.Univalence.SIP"
] | src/1Lab/intro.lagda.md | idea | |
convenience : A type family over $A$ is a function $A \to \ty_i$, for | function | src | [
"open import 1Lab.Prelude hiding (fibre)",
"open import 1Lab.Path",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Equiv.Biinv",
"open import 1Lab.Equiv.HalfAdjoint",
"open import 1Lab.Counterexamples.IsIso",
"open import 1Lab.Univalence",
"open import 1Lab.Univalence.SIP"
] | src/1Lab/intro.lagda.md | convenience | |
_ : Type | function | src | [
"open import 1Lab.Prelude hiding (fibre)",
"open import 1Lab.Path",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Equiv.Biinv",
"open import 1Lab.Equiv.HalfAdjoint",
"open import 1Lab.Counterexamples.IsIso",
"open import 1Lab.Univalence",
"open import 1Lab.Univalence.SIP"
] | src/1Lab/intro.lagda.md | _ | |
interpretation : if we interpret a type $A$ as a space, then for a pair | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | interpretation | |
refl : ∀ {ℓ} {A : Type ℓ} {x : A} → x ≡ x | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | refl | |
Path : ∀ {ℓ} (A : Type ℓ) (x y : A) → Type ℓ | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | Path | |
sym : ∀ {ℓ} {A : Type ℓ} {x y : A} → x ≡ y → y ≡ x | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | sym | |
transport : ∀ {ℓ} {A B : Type ℓ} → A ≡ B → A → B | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | transport | |
identity : ```agda | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | identity | |
_ : ∀ {ℓ} {A : Type ℓ} → transp (λ i → A) i1 ≡ id | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | _ | |
transport-refl : ∀ {ℓ} {A : Type ℓ} (x : A) → transport refl x ≡ x | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | transport-refl | |
_ : {x : Nat} → transport (λ i → Nat) x ≡ x | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | _ | |
_ : {X : Type} → transport (λ i → Type) X ≡ X | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | _ | |
Singleton : ∀ {ℓ} {A : Type ℓ} → A → Type _ | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | Singleton | |
inspect : ∀ {a} {A : Type a} (x : A) → Singleton x | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | inspect | |
composition : the **homogeneous composition** operation, `hcomp`{.Agda}. | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | composition | |
_ : (x : A) {y z : A} (p : x ≡ y) (q : y ≡ z) → p ∙' q ≡ p ∙ q | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | _ | |
type : they move a value from $\iZ/\iO$ to an arbitrary $i$. | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | type | |
to-from-pathp : ∀ {ℓ} {A : I → Type ℓ} {x y} (p : PathP A x y) → to-pathp (from-pathp p) ≡ p | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | to-from-pathp | |
along : ∀ {ℓ} {A : I → Type ℓ} {x : A i0} {y : A i1} → (i : I) → PathP A x y → A i | function | src | [
"open import 1Lab.Type",
"open import Prim.Data.Bool",
"open import Prim.Extension",
"open import Prim.Interval",
"open import Prim.Kan"
] | src/1Lab/Path.lagda.md | along | |
Args : Type | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | Args | |
Fun : ∀ {ℓ ℓ'} → Type ℓ → Type ℓ' → Type (ℓ ⊔ ℓ') | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | Fun | |
idfun : ∀ {ℓ} (A : Type ℓ) → A → A | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | idfun | |
under-abs : ∀ {ℓ} {A : Type ℓ} → Term → TC A → TC A | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | under-abs | |
new-meta : Term → TC Term | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | new-meta | |
new-meta' : Term → TC (Meta × Term) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | new-meta' | |
block-on-meta : ∀ {a} {A : Type a} → Meta → TC A | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | block-on-meta | |
vlam : String → Term → Term | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | vlam | |
infer-hidden : Nat → Args → Args | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | infer-hidden | |
infer-tel : Telescope → Args | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | infer-tel | |
resetting : ∀ {ℓ} {A : Type ℓ} → TC A → TC A | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | resetting | |
all-metas-in : Term → List Blocker | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | all-metas-in | |
wait-for-type : Term → TC Term | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | wait-for-type | |
wait-just-a-bit : Term → TC Term | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | wait-just-a-bit | |
blocking-meta : Term → Maybe Blocker | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | blocking-meta | |
reduceB : Term → TC Term | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | reduceB | |
unapply-path' : Bool → Term → TC (Maybe (Term × Term × Term)) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | unapply-path' | |
get-boundary : Term → TC (Maybe (Term × Term)) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | get-boundary | |
quote-repr-macro : ∀ {ℓ} {A : Type ℓ} → A → Term → TC ⊤ | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | quote-repr-macro | |
unify-loudly : Term → Term → TC ⊤ | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.Path",
"open import 1Lab.Type hiding (absurd)",
"open import Data.Product.NAry",
"open import Data.String.Show",
"open import Data.Bool.Base",
"open import Data.List.Base",
"open import Data.Dec.Base",
"open import Data.Vec.Base",
"open import Meta.... | src/1Lab/Reflection.lagda.md | unify-loudly | |
Ω : Type where constructor el field ∣_∣ : Type is-tr : is-prop ∣_∣ | record | src | [
"open import 1Lab.Function.Surjection",
"open import 1Lab.Path.IdentitySystem",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Universe",
"open import 1Lab.Extensionality",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Reflection using (arg ; typeError)",
"open import 1Lab.Trunc... | src/1Lab/Resizing.lagda.md | Ω | |
Ω-ua : {A B : Ω} → (∣ A ∣ → ∣ B ∣) → (∣ B ∣ → ∣ A ∣) → A ≡ B | function | src | [
"open import 1Lab.Function.Surjection",
"open import 1Lab.Path.IdentitySystem",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Universe",
"open import 1Lab.Extensionality",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Reflection using (arg ; typeError)",
"open import 1Lab.Trunc... | src/1Lab/Resizing.lagda.md | Ω-ua | |
elΩ : ∀ {ℓ} (T : Type ℓ) → Ω | function | src | [
"open import 1Lab.Function.Surjection",
"open import 1Lab.Path.IdentitySystem",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Universe",
"open import 1Lab.Extensionality",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Reflection using (arg ; typeError)",
"open import 1Lab.Trunc... | src/1Lab/Resizing.lagda.md | elΩ | |
nothing : ```agda | function | src | [
"open import 1Lab.Reflection.Induction",
"open import 1Lab.Function.Embedding",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Path.Reasoning",
"open import 1Lab.Type.Sigma",
"open import 1Lab.Inductive",
"open import 1Lab.Type.Pi",
"open import 1Lab.HLeve... | src/1Lab/Truncation.lagda.md | nothing | |
slightly : Can we map out of $\| A \|$ using a _constant_ function? | function | src | [
"open import 1Lab.Reflection.Induction",
"open import 1Lab.Function.Embedding",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Path.Reasoning",
"open import 1Lab.Type.Sigma",
"open import 1Lab.Inductive",
"open import 1Lab.Type.Pi",
"open import 1Lab.HLeve... | src/1Lab/Truncation.lagda.md | slightly | |
image : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} → (A → B) → Type _ | function | src | [
"open import 1Lab.Reflection.Induction",
"open import 1Lab.Function.Embedding",
"open import 1Lab.Reflection.HLevel",
"open import 1Lab.HLevel.Closure",
"open import 1Lab.Path.Reasoning",
"open import 1Lab.Type.Sigma",
"open import 1Lab.Inductive",
"open import 1Lab.Type.Pi",
"open import 1Lab.HLeve... | src/1Lab/Truncation.lagda.md | image | |
Lift {a} ℓ (A : Type a) : Type (a ⊔ ℓ) where constructor lift field lower : A ``` <!-- ```agda | record | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | Lift | |
_ : (ℓ : Level) → Type (lsuc ℓ) | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | _ | |
level-of : {ℓ : Level} → Type ℓ → Level | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | level-of | |
absurd : ∀ {ℓ} {A : Type ℓ} → .⊥ → A | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | absurd | |
id : ∀ {ℓ} {A : Type ℓ} → A → A | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | id | |
auto : ∀ {ℓ} {A : Type ℓ} → ⦃ A ⦄ → A | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | auto | |
case_of_ : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} → A → (A → B) → B | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | case_of_ | |
case_return_of_ : ∀ {ℓ ℓ'} {A : Type ℓ} (x : A) (B : A → Type ℓ') (f : (x : A) → B x) → B x | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | case_return_of_ | |
absurdω : {A : Typeω} → .⊥ → A | function | src | [
"open import Prim.Type hiding (Prop) public",
"open import Prim.Data.Sigma public",
"open import Prim.Data.Bool public",
"open import Prim.Data.Nat hiding (_<_) public",
"open import Prim.Literals public"
] | src/1Lab/Type.lagda.md | absurdω | |
axiom : the **univalence axiom**. | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | axiom | |
equivalences : `path→equiv`{.Agda} | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | equivalences | |
ua : {A B : Type ℓ} → A ≃ B → A ≡ B | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | ua | |
uaβ : {A B : Type ℓ} (f : A ≃ B) (x : A) → transport (ua f) x ≡ f .fst x | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | uaβ | |
ua-unglue : ∀ {A B : Type ℓ} (e : A ≃ B) (i : I) (x : ua e i) → B | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | ua-unglue | |
ua-id-equiv : {A : Type ℓ} → ua (_ , id-equiv {A = A}) ≡ refl | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | ua-id-equiv | |
univalence : {A B : Type ℓ} → is-equiv (path→equiv {A = A} {B}) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | univalence | |
Equiv-is-contr : ∀ {ℓ} (A : Type ℓ) → is-contr (Σ[ B ∈ Type ℓ ] A ≃ B) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | Equiv-is-contr | |
Total-equiv : (p : E → B) → E ≃ Σ B (fibre p) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | Total-equiv | |
sym-ua : ∀ {ℓ} {A B : Type ℓ} (e : A ≃ B) → sym (ua e) ≡ ua (e e⁻¹) | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | sym-ua | |
ua-inc : ∀ {ℓ} {A₀ A₁ : Type ℓ} (e : A₀ ≃ A₁) (x : A₀) (i : I) → ua e i | function | src | [
"open import 1Lab.Type.Sigma",
"open import 1Lab.HLevel",
"open import 1Lab.Equiv",
"open import 1Lab.Path",
"open import 1Lab.Type",
"open import Prim.HCompU",
"open import 1Lab.Equiv.FromPath"
] | src/1Lab/Univalence.lagda.md | ua-inc | |
is-group {ℓ} {A : Type ℓ} (_*_ : A → A → A) : Type ℓ where no-eta-equality field unit : A ``` There is also a map which assigns to each element $x$ its _`inverse`{.Agda ident=inverse}_ $x\inv$, and this inverse must multiply with $x$ to give the unit, both on the left and on the right: ```agda inverse : A → A has-is-mo... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Magma.Unital hiding (idl ; idr)",
"open import Algebra.Semigroup",
"open import Algebra.Monoid",
"open import Algebra.Magma",
"import Algebra.Monoid.Reasoning as Mon"
] | src/Algebra/Group.lagda.md | is-group | |
Group-on {ℓ} (A : Type ℓ) : Type ℓ where field _⋆_ : A → A → A has-is-group : is-group _⋆_ infixr 20 _⋆_ infixl 35 _⁻¹ _⁻¹ : A → A x ⁻¹ = has-is-group .is-group.inverse x open is-group has-is-group public ``` We have that a map `is a group homomorphism`{.Agda ident=is-group-hom} if it `preserves the multiplication`{.Ag... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Magma.Unital hiding (idl ; idr)",
"open import Algebra.Semigroup",
"open import Algebra.Monoid",
"open import Algebra.Magma",
"import Algebra.Monoid.Reasoning as Mon"
] | src/Algebra/Group.lagda.md | Group-on | |
is-group-hom {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} (G : Group-on A) (G' : Group-on B) (e : A → B) : Type (ℓ ⊔ ℓ') where private module A = Group-on G module B = Group-on G' field pres-⋆ : (x y : A) → e (x A.⋆ y) ≡ e x B.⋆ e y ``` A tedious calculation shows that this is sufficient to preserve the identity and inverses: ```... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Magma.Unital hiding (idl ; idr)",
"open import Algebra.Semigroup",
"open import Algebra.Monoid",
"open import Algebra.Magma",
"import Algebra.Monoid.Reasoning as Mon"
] | src/Algebra/Group.lagda.md | is-group-hom | |
make-group {ℓ} (G : Type ℓ) : Type ℓ where no-eta-equality field group-is-set : is-set G unit : G mul : G → G → G inv : G → G assoc : ∀ x y z → mul x (mul y z) ≡ mul (mul x y) z invl : ∀ x → mul (inv x) x ≡ unit idl : ∀ x → mul unit x ≡ x private invr : ∀ x → mul x (inv x) ≡ unit invr x = mul x (inv x) ≡˘⟨ idl _ ⟩ mul ... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Magma.Unital hiding (idl ; idr)",
"open import Algebra.Semigroup",
"open import Algebra.Monoid",
"open import Algebra.Magma",
"import Algebra.Monoid.Reasoning as Mon"
] | src/Algebra/Group.lagda.md | make-group | |
is-magma {A : Type ℓ} (_⋆_ : A → A → A) : Type ℓ where ``` A **magma** is a `set`{.Agda ident=is-set} equipped with an arbitrary binary operation `⋆`, on which no further laws are imposed. ```agda field has-is-set : is-set A underlying-set : Set ℓ underlying-set = el _ has-is-set opaque instance magma-hlevel : ∀ {n} → ... | record | src | [
"open import 1Lab.Univalence.SIP",
"open import 1Lab.Prelude",
"open import Data.Bool"
] | src/Algebra/Magma.lagda.md | is-magma | |
Magma-on (A : Type ℓ) : Type ℓ where field _⋆_ : A → A → A has-is-magma : is-magma _⋆_ open is-magma has-is-magma public Magma : (ℓ : Level) → Type (lsuc ℓ) Magma ℓ = Σ (Type ℓ) Magma-on ``` We then define what it means for an equivalence between the carrier types of two given magmas to be an **equivalence of magmas**:... | record | src | [
"open import 1Lab.Univalence.SIP",
"open import 1Lab.Prelude",
"open import Data.Bool"
] | src/Algebra/Magma.lagda.md | Magma-on | |
Magma ≃ (A B : Magma ℓ) (e : A .fst ≃ B .fst) : Type ℓ where private module A = Magma-on (A .snd) module B = Magma-on (B .snd) field pres-⋆ : (x y : A .fst) → e .fst (x A.⋆ y) ≡ e .fst x B.⋆ e .fst y | record | src | [
"open import 1Lab.Univalence.SIP",
"open import 1Lab.Prelude",
"open import Data.Bool"
] | src/Algebra/Magma.lagda.md | Magma | |
is-magma-is-prop : {_⋆_ : A → A → A} → is-prop (is-magma _⋆_) | function | src | [
"open import 1Lab.Univalence.SIP",
"open import 1Lab.Prelude",
"open import Data.Bool"
] | src/Algebra/Magma.lagda.md | is-magma-is-prop | |
Magma : (ℓ : Level) → Type (lsuc ℓ) | function | src | [
"open import 1Lab.Univalence.SIP",
"open import 1Lab.Prelude",
"open import Data.Bool"
] | src/Algebra/Magma.lagda.md | Magma | |
is-monoid (id : A) (_⋆_ : A → A → A) : Type (level-of A) where field has-is-semigroup : is-semigroup _⋆_ open is-semigroup has-is-semigroup public field idl : {x : A} → id ⋆ x ≡ x idr : {x : A} → x ⋆ id ≡ x | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Semigroup",
"open import Algebra.Magma.Unital"
] | src/Algebra/Monoid.lagda.md | is-monoid | |
Monoid-on (A : Type ℓ) : Type ℓ where field identity : A _⋆_ : A → A → A has-is-monoid : is-monoid identity _⋆_ open is-monoid has-is-monoid public Monoid : (ℓ : Level) → Type (lsuc ℓ) Monoid ℓ = Σ (Type ℓ) Monoid-on ``` There is also a predicate which witnesses when an equivalence between monoids is a monoid homomorph... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Semigroup",
"open import Algebra.Magma.Unital"
] | src/Algebra/Monoid.lagda.md | Monoid-on | |
Monoid-hom {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} (s : Monoid-on A) (t : Monoid-on B) (e : A → B) : Type (ℓ ⊔ ℓ') where private module A = Monoid-on s module B = Monoid-on t field pres-id : e A.identity ≡ B.identity pres-⋆ : (x y : A) → e (x A.⋆ y) ≡ e x B.⋆ e y | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Semigroup",
"open import Algebra.Magma.Unital"
] | src/Algebra/Monoid.lagda.md | Monoid-hom | |
make-monoid {ℓ} (A : Type ℓ) : Type ℓ where field monoid-is-set : is-set A _⋆_ : A → A → A 1M : A ⋆-assoc : ∀ x y z → x ⋆ (y ⋆ z) ≡ (x ⋆ y) ⋆ z ⋆-idl : ∀ x → 1M ⋆ x ≡ x ⋆-idr : ∀ x → x ⋆ 1M ≡ x to-is-monoid : is-monoid 1M _⋆_ to-is-monoid .has-is-semigroup .is-semigroup.has-is-magma = record { has-is-set = monoid-is-se... | record | src | [
"open import 1Lab.Prelude",
"open import Algebra.Semigroup",
"open import Algebra.Magma.Unital"
] | src/Algebra/Monoid.lagda.md | make-monoid |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.