Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. • 84 items • Updated • 3
fact stringlengths 18 10.3k | type stringclasses 3
values | library stringclasses 1
value | imports listlengths 2 31 | filename stringlengths 20 76 | symbolic_name stringlengths 1 32 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
2-Category : (o ℓ e t : Level) → Set (suc (o ⊔ ℓ ⊔ e ⊔ t)) | function | src | [
"open import Level",
"open import Categories.Category.Monoidal.Instance.StrictCats using (module Product)",
"open import Categories.Enriched.Category using (Category)"
] | src/Categories/2-Category.agda | 2-Category | |
Adjoint (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ levelOfTerm R) where private module C = Category C module D = Category D module L = Functor L module R = Functor R field unit : NaturalTransformation idF (R ∘F L) counit : NaturalTransformation (L ∘F R) idF module unit = NaturalTransformation unit modul... | record | src | [
"open import Level",
"open import Data.Product using (_,_; _×_)",
"open import Function using (_$_) renaming (_∘_ to _∙_)",
"open import Function.Bundles using (Inverse)",
"open import Relation.Binary using (Rel; IsEquivalence; Setoid)",
"open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)"... | src/Categories/Adjoint.agda | Adjoint | |
Bicategory o ℓ e t : Set (suc (o ⊔ ℓ ⊔ e ⊔ t)) where field enriched : Enriched (Product.Cats-Monoidal {o} {ℓ} {e}) t open Enriched enriched public module hom {A B} = Category (hom A B) module ComHom {A B} = Commutation (hom A B) infix 4 _⇒₁_ _⇒₂_ _≈_ infixr 7 _∘ᵥ_ _∘₁_ infixr 9 _▷_ infixl 9 _◁_ infixr 11 _⊚₀_ _⊚₁_ _∘ₕ_... | record | src | [
"open import Level",
"open import Data.Product using (_,_)",
"open import Relation.Binary using (Rel)",
"open import Categories.Category using (Category; module Commutation)",
"open import Categories.Category.Monoidal.Instance.Cats using (module Product)",
"open import Categories.Enriched.Category using (... | src/Categories/Bicategory.agda | Bicategory | |
Comonad {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where field F : Endofunctor C ε : NaturalTransformation F idF δ : NaturalTransformation F (F ∘F F) module F = Functor F module ε = NaturalTransformation ε module δ = NaturalTransformation δ open Category C open Functor F field assoc : ∀ {X : Obj} → δ.η (F₀ X) ∘ δ.η... | record | src | [
"open import Level",
"open import Categories.Category using (Category)",
"open import Categories.Functor using (Functor; Endofunctor; _∘F_) renaming (id to idF)",
"open import Categories.NaturalTransformation renaming (id to idN)",
"open import Categories.NaturalTransformation.NaturalIsomorphism hiding (_≃_... | src/Categories/Comonad.agda | Comonad | |
Endofunctor : Category o ℓ e → Set _ | function | src | [
"open import Level",
"open import Function renaming (id to id→; _∘_ to _●_) using ()",
"open import Categories.Category",
"open import Categories.Functor.Core public"
] | src/Categories/Functor.agda | Endofunctor | |
id : ∀ {C : Category o ℓ e} → Functor C C | function | src | [
"open import Level",
"open import Function renaming (id to id→; _∘_ to _●_) using ()",
"open import Categories.Category",
"open import Categories.Functor.Core public"
] | src/Categories/Functor.agda | id | |
GlobularSet : (o : Level) → Set (suc o) | function | src | [
"open import Level",
"open import Data.Unit using (⊤)",
"open import Relation.Binary.PropositionalEquality using (refl)",
"open import Categories.Category",
"open import Categories.Category.Instance.Globe",
"open import Categories.Category.Instance.Sets",
"open import Categories.Functor",
"open import... | src/Categories/GlobularSet.agda | GlobularSet | |
Trivial : GlobularSet zero | function | src | [
"open import Level",
"open import Data.Unit using (⊤)",
"open import Relation.Binary.PropositionalEquality using (refl)",
"open import Categories.Category",
"open import Categories.Category.Instance.Globe",
"open import Categories.Category.Instance.Sets",
"open import Categories.Functor",
"open import... | src/Categories/GlobularSet.agda | Trivial | |
GlobularObject : Category o ℓ e → Set _ | function | src | [
"open import Level",
"open import Data.Unit using (⊤)",
"open import Relation.Binary.PropositionalEquality using (refl)",
"open import Categories.Category",
"open import Categories.Category.Instance.Globe",
"open import Categories.Category.Instance.Sets",
"open import Categories.Functor",
"open import... | src/Categories/GlobularSet.agda | GlobularObject | |
-2-Category : Set (suc (o ⊔ ℓ ⊔ e)) where field cat : Category o ℓ e open Category cat public open M cat using (_≅_) field Obj-Contr : Σ Obj (λ x → (y : Obj) → x ≅ y) Hom-Conn : {x y : Obj} {f g : x ⇒ y} → f ≈ g | record | src | [
"open import Level",
"open import Categories.Category",
"open import Data.Product using (Σ)",
"import Categories.Morphism as M"
] | src/Categories/Minus2-Category.agda | -2-Category | |
Monad {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where field F : Endofunctor C η : NaturalTransformation idF F μ : NaturalTransformation (F ∘F F) F module F = Functor F module η = NaturalTransformation η module μ = NaturalTransformation μ open Category C open F field assoc : ∀ {X : Obj} → μ.η X ∘ F₁ (μ.η X) ≈ μ.η X... | record | src | [
"open import Level",
"open import Categories.Category using (Category)",
"open import Categories.Functor using (Functor; Endofunctor; _∘F_) renaming (id to idF)",
"open import Categories.NaturalTransformation renaming (id to idN)",
"open import Categories.NaturalTransformation.NaturalIsomorphism hiding (_≃_... | src/Categories/Monad.agda | Monad | |
_ ↣_ (A B : Obj) : Set (o ⊔ ℓ ⊔ e) where field mor : A ⇒ B mono : Mono mor Epi : ∀ (f : A ⇒ B) → Set (o ⊔ ℓ ⊔ e) Epi {B = B} f = ∀ {C} → (g₁ g₂ : B ⇒ C) → g₁ ∘ f ≈ g₂ ∘ f → g₁ ≈ g₂ JointEpi : (I : Set) (A : I → Obj) → ((i : I) → A i ⇒ B) → Set (o ⊔ ℓ ⊔ e) JointEpi {B} I A f = ∀ {C} → (g₁ g₂ : B ⇒ C) → ((i : I) → g₁ ∘ f... | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | _ | |
_ ↠_ (A B : Obj) : Set (o ⊔ ℓ ⊔ e) where field mor : A ⇒ B epi : Epi mor _SectionOf_ : (g : B ⇒ A) (f : A ⇒ B) → Set e g SectionOf f = f ∘ g ≈ id _RetractOf_ : (g : B ⇒ A) (f : A ⇒ B) → Set e g RetractOf f = g ∘ f ≈ id | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | _ | |
Retract (X U : Obj) : Set (ℓ ⊔ e) where field section : X ⇒ U retract : U ⇒ X is-retract : retract ∘ section ≈ id | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | Retract | |
Iso (from : A ⇒ B) (to : B ⇒ A) : Set e where field isoˡ : to ∘ from ≈ id isoʳ : from ∘ to ≈ id -- We often say that a morphism "is an iso" if there exists some inverse to it. -- This does buck the naming convention we use somewhat, but it lines up -- better with the literature. | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | Iso | |
IsIso (from : A ⇒ B) : Set (ℓ ⊔ e) where field inv : B ⇒ A iso : Iso from inv open Iso iso public infix 4 _≅_ | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | IsIso | |
_ ≅_ (A B : Obj) : Set (ℓ ⊔ e) where field from : A ⇒ B to : B ⇒ A iso : Iso from to open Iso iso public -- don't pollute the name space too much private ≅-refl : Reflexive _≅_ ≅-refl = record { from = id ; to = id ; iso = record { isoˡ = identity² ; isoʳ = identity² } } ≅-sym : Symmetric _≅_ ≅-sym A≅B = record { from ... | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | _ | |
Mono : ∀ (f : A ⇒ B) → Set (o ⊔ ℓ ⊔ e) | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | Mono | |
JointMono : {ι : Level} (I : Set ι) (B : I → Obj) → ((i : I) → A ⇒ B i) → Set (o ⊔ ℓ ⊔ e ⊔ ι) | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | JointMono | |
Epi : ∀ (f : A ⇒ B) → Set (o ⊔ ℓ ⊔ e) | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | Epi | |
JointEpi : (I : Set) (A : I → Obj) → ((i : I) → A i ⇒ B) → Set (o ⊔ ℓ ⊔ e) | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | JointEpi | |
_SectionOf_ : (g : B ⇒ A) (f : A ⇒ B) → Set e | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | _SectionOf_ | |
_RetractOf_ : (g : B ⇒ A) (f : A ⇒ B) → Set e | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary hiding (_⇒_)",
"open import Categories.Morphism.Reasoning.Core 𝒞"
] | src/Categories/Morphism.agda | _RetractOf_ | |
Pseudofunctor : Set (o ⊔ ℓ ⊔ e ⊔ t ⊔ o′ ⊔ ℓ′ ⊔ e′ ⊔ t′) where field P₀ : C.Obj → D.Obj P₁ : {x y : C.Obj} → Functor (C.hom x y) (D.hom (P₀ x) (P₀ y)) -- For maximal generality, shift the levels of One. P preserves id P-identity : {A : C.Obj} → D.id {P₀ A} ∘F shift o′ ℓ′ e′ ≃ P₁ ∘F (C.id {A}) -- P preserves composition ... | record | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Level",
"open import Data.Product using (_,_)",
"import Categories.Bicategory.Extras as BicategoryExtras",
"open import Categories.Category using (Category; _[_,_]; module Commutation)",
"open import Categories.Category.Instance.One usin... | src/Categories/Pseudofunctor.agda | Pseudofunctor | |
Quiver o ℓ e : Set (suc (o ⊔ ℓ ⊔ e)) where infix 4 _≈_ _⇒_ field Obj : Set o _⇒_ : Rel Obj ℓ _≈_ : ∀ {A B} → Rel (A ⇒ B) e equiv : ∀ {A B} → IsEquivalence (_≈_ {A} {B}) setoid : {A B : Obj} → Setoid _ _ setoid {A} {B} = record { Carrier = A ⇒ B ; _≈_ = _≈_ ; isEquivalence = equiv } module Equiv {A B : Obj} = IsEquivale... | record | src | [
"open import Level",
"open import Relation.Binary using (Rel; IsEquivalence; Setoid)",
"import Relation.Binary.Reasoning.Setoid as EqR"
] | src/Data/Quiver.agda | Quiver | |
refl : ⊣Equivalence C C | function | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.TwoSided",
"open import Categories.Adjoint.TwoSided.Compose",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)",
"open import Categori... | src/Categories/Adjoint/Equivalence.agda | refl | |
sym : ⊣Equivalence C D → ⊣Equivalence D C | function | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.TwoSided",
"open import Categories.Adjoint.TwoSided.Compose",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)",
"open import Categori... | src/Categories/Adjoint/Equivalence.agda | sym | |
trans : ⊣Equivalence C D → ⊣Equivalence D E → ⊣Equivalence C E | function | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.TwoSided",
"open import Categories.Adjoint.TwoSided.Compose",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)",
"open import Categori... | src/Categories/Adjoint/Equivalence.agda | trans | |
isEquivalence : ∀ {o ℓ e} → IsEquivalence (⊣Equivalence {o} {ℓ} {e}) | function | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.TwoSided",
"open import Categories.Adjoint.TwoSided.Compose",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)",
"open import Categori... | src/Categories/Adjoint/Equivalence.agda | isEquivalence | |
setoid : ∀ o ℓ e → Setoid _ _ | function | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.TwoSided",
"open import Categories.Adjoint.TwoSided.Compose",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)",
"open import Categori... | src/Categories/Adjoint/Equivalence.agda | setoid | |
Mate {L : Functor C D} (L⊣R : L ⊣ R) (L′⊣R′ : L′ ⊣ R′) (α : NaturalTransformation L L′) (β : NaturalTransformation R′ R) : Set (levelOfTerm L⊣R ⊔ levelOfTerm L′⊣R′) where private module L⊣R = Adjoint L⊣R module L′⊣R′ = Adjoint L′⊣R′ module C = Category C module D = Category D field commute₁ : (R ∘ˡ α) ∘ᵥ L⊣R.unit ≃ (β ... | record | src | [
"open import Level",
"open import Data.Product using (Σ; _,_)",
"open import Function.Bundles using (Func; _⟨$⟩_)",
"open import Function.Construct.Composition using (function)",
"open import Function.Construct.Setoid using () renaming (setoid to _⇨_)",
"open import Relation.Binary using (Setoid; IsEquiva... | src/Categories/Adjoint/Mate.agda | Mate | |
HaveMate {L L′ : Functor C D} {R R′ : Functor D C} (L⊣R : L ⊣ R) (L′⊣R′ : L′ ⊣ R′) : Set (levelOfTerm L⊣R ⊔ levelOfTerm L′⊣R′) where field α : NaturalTransformation L L′ β : NaturalTransformation R′ R mate : Mate L⊣R L′⊣R′ α β module α = NaturalTransformation α module β = NaturalTransformation β open Mate mate public -... | record | src | [
"open import Level",
"open import Data.Product using (Σ; _,_)",
"open import Function.Bundles using (Func; _⟨$⟩_)",
"open import Function.Construct.Composition using (function)",
"open import Function.Construct.Setoid using () renaming (setoid to _⇨_)",
"open import Relation.Binary using (Setoid; IsEquiva... | src/Categories/Adjoint/Mate.agda | HaveMate | |
IsMonadicAdjunction {L : Functor 𝒞 𝒟} {R : Functor 𝒟 𝒞} (adjoint : L ⊣ R) : Set (levelOfTerm 𝒞 ⊔ levelOfTerm 𝒟) where private T : Monad 𝒞 T = adjoint⇒monad adjoint field Comparison⁻¹ : Functor (EilenbergMoore T) 𝒟 comparison-equiv : WeakInverse (ComparisonF adjoint) Comparison⁻¹ | record | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Adjoint.Properties",
"open import Categories.Category",
"open import Categories.Category.Equivalence",
"open import Categories.Functor",
"open import Categories.Monad",
"open import Categories.Category.Construction.Eilenber... | src/Categories/Adjoint/Monadic.agda | IsMonadicAdjunction | |
ParametricAdjoint {C D E : Category o ℓ e} (L : Functor C (Functors D E)) (R : Functor (Category.op C) (Functors E D)) : Set (o ⊔ ℓ ⊔ e) where private module C = Category C module D = Category D module E = Category E module L = Functor L module R = Functor R -- use double letters whenever we refer to the two-parameters... | record | src | [
"open import Level",
"open import Data.Product using (_×_; _,_)",
"open import Function.Bundles using (Injection; Inverse)",
"open import Function.Properties.Inverse using (Inverse⇒Injection)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor using (Functor; _∘F_) r... | src/Categories/Adjoint/Parametric.agda | ParametricAdjoint | |
ra-preserves-diagram : {L : Functor J K} {R : Functor K J} (L⊣R : L ⊣ R) {F : Functor J C} → Colimit F → Colimit (F ∘F R) | function | src | [
"open import Level",
"open import Data.Product using (Σ; _,_; -,_; proj₂; uncurry)",
"open import Function.Base using (_$_)",
"open import Categories.Adjoint using (_⊣_; Adjoint)",
"open import Categories.Adjoint.Equivalents using (Hom-NI′⇒Adjoint)",
"open import Categories.Adjoint.RAPL using (rapl)",
"... | src/Categories/Adjoint/Properties.agda | ra-preserves-diagram | |
RelativeAdjoint {C : Category o ℓ e} (D : Category o ℓ e) (J : Functor E C) : Set (levelOfTerm D ⊔ levelOfTerm J) where field L : Functor E D R : Functor D C private module C = Category C module D = Category D module E = Category E module L = Functor L module R = Functor R module J = Functor J Hom[L-,-] : Bifunctor E.o... | record | src | [
"open import Level",
"open import Data.Product using (_,_; _×_)",
"open import Function using (_$_) renaming (_∘_ to _∙_)",
"open import Function.Bundles using (Func; _⟨$⟩_)",
"open import Relation.Binary using (Setoid)",
"open import Categories.Adjoint",
"open import Categories.Category.Core using (Cat... | src/Categories/Adjoint/Relative.agda | RelativeAdjoint | |
_ ⊣⊢_ (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ levelOfTerm R) where field unit : idF ≃ (R ∘F L) counit : (L ∘F R) ≃ idF module unit = NaturalIsomorphism unit module counit = NaturalIsomorphism counit private module C = Category C using (Obj; id; _∘_; _≈_; module HomReasoning) module D = Category D usi... | record | src | [
"open import Level",
"open import Categories.Adjoint",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.Functor.Properties",
"open import Categories.NaturalTransformation using (ntHelper)",
"open import Categories.Nat... | src/Categories/Adjoint/TwoSided.agda | _ | |
IsBigroupoid {o ℓ e t} (C : Bicategory o ℓ e t) : Set (o ⊔ ℓ ⊔ e ⊔ t) where open BicategoryExtras C open Shorthands field hom-isGroupoid : ∀ A B → IsGroupoid (hom A B) hom[_,_]⁻¹ : ∀ A B → Functor (hom A B) (hom B A) cancel : ∀ A B → ⊚ ∘F (hom[ A , B ]⁻¹ ※ idF) ≃ const id₁ cancel′ : ∀ A B → ⊚ ∘F (idF ※ hom[ A , B ]⁻¹) ... | record | src | [
"open import Level",
"open import Function using (_$_)",
"open import Data.Product using (Σ; _,_)",
"open import Categories.Adjoint.TwoSided using (_⊣⊢_)",
"open import Categories.Category",
"open import Categories.Category.Equivalence using (WeakInverse)",
"import Categories.Category.Equivalence.Proper... | src/Categories/Bicategory/Bigroupoid.agda | IsBigroupoid | |
Bigroupoid (o ℓ e t : Level) : Set (suc (o ⊔ ℓ ⊔ e ⊔ t)) where field bicategory : Bicategory o ℓ e t isBigroupoid : IsBigroupoid bicategory open IsBigroupoid isBigroupoid public | record | src | [
"open import Level",
"open import Function using (_$_)",
"open import Data.Product using (Σ; _,_)",
"open import Categories.Adjoint.TwoSided using (_⊣⊢_)",
"open import Categories.Category",
"open import Categories.Category.Equivalence using (WeakInverse)",
"import Categories.Category.Equivalence.Proper... | src/Categories/Bicategory/Bigroupoid.agda | Bigroupoid | |
unitorˡ : {A B : Obj} {f : A ⇒₁ B} → id₁ ∘₁ f ≅ f | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | unitorˡ | |
unitorʳ : {A B : Obj} {f : A ⇒₁ B} → f ∘₁ id₁ ≅ f | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | unitorʳ | |
identity₂ˡ : id₂ ∘ᵥ α ≈ α | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | identity₂ˡ | |
identity₂ʳ : α ∘ᵥ id₂ ≈ α | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | identity₂ʳ | |
identity₂² : id₂ ∘ᵥ id₂ {f = g} ≈ id₂ {f = g} | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | identity₂² | |
assoc₂ : (α ∘ᵥ β) ∘ᵥ γ ≈ α ∘ᵥ β ∘ᵥ γ | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | assoc₂ | |
sym-assoc₂ : α ∘ᵥ β ∘ᵥ γ ≈ (α ∘ᵥ β) ∘ᵥ γ | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | sym-assoc₂ | |
triangle-inv : {f : A ⇒₁ B} {g : B ⇒₁ C} → α⇐ ∘ᵥ g ▷ λ⇐ ≈ ρ⇐ ◁ f | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Category.Construction.Core as Core",
"open import Categories.Category.Construction.Functors using (Functors; module curry)",
"open import Categories.Functor using (Functor)",
"open import Cat... | src/Categories/Bicategory/Extras.agda | triangle-inv | |
LocalCoequalizers : Set (o ⊔ ℓ ⊔ e ⊔ t) where field localCoequalizers : (A B : Obj) → Coequalizers (hom A B) precompPreservesCoequalizer : {A B E : Obj} → (f : E ⇒₁ A) → PreservesCoequalizers (-⊚_ {E} {A} {B} f) postcompPreservesCoequalizer : {A B E : Obj} → (f : B ⇒₁ E) → PreservesCoequalizers (_⊚- {B} {E} {A} f) | record | src | [
"open import Categories.Bicategory",
"open import Categories.Diagram.Coequalizer using (Coequalizer; Coequalizers)",
"open import Level using (_⊔_)",
"open import Categories.Functor.Properties using (PreservesCoequalizers)",
"import Categories.Bicategory.Extras as Bicat"
] | src/Categories/Bicategory/LocalCoequalizers.agda | LocalCoequalizers | |
Monad {o ℓ e t} (𝒞 : Bicategory o ℓ e t) : Set (o ⊔ ℓ ⊔ e ⊔ t) where open Bicat 𝒞 field C : Obj T : C ⇒₁ C η : id₁ ⇒₂ T μ : (T ⊚₀ T) ⇒₂ T assoc : μ ∘ᵥ (T ▷ μ) ∘ᵥ associator.from ≈ (μ ∘ᵥ (μ ◁ T)) sym-assoc : μ ∘ᵥ (μ ◁ T) ∘ᵥ associator.to ≈ (μ ∘ᵥ (T ▷ μ)) identityˡ : μ ∘ᵥ (T ▷ η) ∘ᵥ unitorʳ.to ≈ id₂ identityʳ : μ ∘ᵥ (η... | record | src | [
"open import Level",
"open import Data.Product using (_,_)",
"open import Categories.Bicategory",
"import Categories.Bicategory.Extras as Bicat",
"open import Categories.NaturalTransformation.NaturalIsomorphism using (NaturalIsomorphism)"
] | src/Categories/Bicategory/Monad.agda | Monad | |
coop : ∀ {o ℓ e t} → Bicategory o ℓ e t → Bicategory o ℓ e t | function | src | [
"open import Categories.Bicategory using (Bicategory)",
"open import Data.Product using (_,_)",
"import Categories.Bicategory.Extras as BicategoryExtras",
"open import Categories.Category using (Category)",
"import Categories.Category.Cartesian as Cartesian",
"import Categories.Morphism as Morphism",
"i... | src/Categories/Bicategory/Opposite.agda | coop | |
BicartesianClosed : Set (levelOfTerm 𝒞) where field cartesianClosed : CartesianClosed cocartesian : Cocartesian | record | src | [
"open import Categories.Category.Core using (Category)",
"open import Level",
"open import Categories.Category.CartesianClosed 𝒞",
"open import Categories.Category.Cocartesian 𝒞"
] | src/Categories/Category/BicartesianClosed.agda | BicartesianClosed | |
BinaryProducts : Set (levelOfTerm 𝒞) where infixr 7 _×_ infixr 8 _⁂_ infix 11 ⟨_,_⟩ field product : ∀ {A B} → Product A B private module product {A} {B} = Product (product {A} {B}) _×_ : Obj → Obj → Obj A × B = Product.A×B (product {A} {B}) ×-comm : A × B ≅ B × A ×-comm = Commutative product product ×-assoc : X × Y × ... | record | src | [
"open import Categories.Category.Core using (Category)",
"open import Level hiding (suc)",
"open import Data.Product using (uncurry)",
"open import Categories.Object.Product 𝒞",
"open import Categories.Morphism 𝒞 using (_≅_; module Iso; Mono; Epi)",
"open import Categories.Morphism.Reasoning 𝒞 using (p... | src/Categories/Category/BinaryProducts.agda | BinaryProducts | |
Cartesian : Set (levelOfTerm 𝒞) where field terminal : Terminal products : BinaryProducts open BinaryProducts products using (_×_) power : Obj → ℕ → Obj power A 0 = Terminal.⊤ terminal power A 1 = A power A (suc (suc n)) = A × power A (suc n) | record | src | [
"open import Categories.Category using (Category)",
"open import Level using (levelOfTerm)",
"open import Data.Nat using (ℕ; zero; suc)",
"open import Categories.Category.BinaryProducts 𝒞 using (BinaryProducts; module BinaryProducts)",
"open import Categories.Object.Terminal 𝒞 using (Terminal)"
] | src/Categories/Category/Cartesian.agda | Cartesian | |
CartesianClosed : Set (levelOfTerm 𝒞) where infixr 9 _^_ -- an alternative notation for exponential, which emphasizes its internal hom natural infixr 5 _⇨_ field cartesian : Cartesian exp : Exponential A B module exp {A B} = Exponential (exp {A} {B}) _^_ : Obj → Obj → Obj B ^ A = exp.B^A {A} {B} _⇨_ : Obj → Obj → Obj ... | record | src | [
"open import Categories.Category",
"open import Level",
"open import Function using (_$_; flip)",
"open import Data.Product using (Σ; _,_; uncurry)",
"open import Categories.Category.BinaryProducts 𝒞",
"open import Categories.Category.Cartesian 𝒞",
"open import Categories.Category.Cartesian.Monoidal u... | src/Categories/Category/CartesianClosed.agda | CartesianClosed | |
Closed : Set (levelOfTerm C) where field -- internal hom [-,-] : Bifunctor C.op C C unit : Obj [_,-] : Obj → Functor C C [_,-] = appˡ [-,-] [-,_] : Obj → Functor C.op C [-,_] = appʳ [-,-] module [-,-] = Functor [-,-] [_,_]₀ : Obj → Obj → Obj [ X , Y ]₀ = [-,-].F₀ (X , Y) [_,_]₁ : A ⇒ B → X ⇒ Y → [ B , X ]₀ ⇒ [ A , Y ]₀... | record | src | [
"open import Categories.Category using (Category; module Commutation)",
"open import Level using (Level; levelOfTerm)",
"open import Data.Product using (Σ; _,_)",
"open import Function.Bundles using (Func; Inverse)",
"open import Function.Definitions using (Inverseᵇ)",
"open import Categories.Category.Pro... | src/Categories/Category/Closed.agda | Closed | |
CM-Category (o ℓ e : Level) : Set (suc (o ⊔ ℓ ⊔ e)) where infix 4 _≈_ _⇒_ infixr 9 _∘_ infixl 7 _+_ open CommutativeMonoid using (_∙_; ε) renaming (Carrier to ∣_∣) field Obj : Set o Hom : (A B : Obj) → CommutativeMonoid ℓ e _⇒_ : (A B : Obj) → Set ℓ A ⇒ B = ∣ Hom A B ∣ _+_ : {A B : Obj} → A ⇒ B → A ⇒ B → A ⇒ B _+_ {A} ... | record | src | [
"open import Level",
"open import Algebra.Bundles using (CommutativeMonoid)",
"open import Function.Base using (flip)",
"open import Relation.Binary using (Rel; IsEquivalence)",
"open import Categories.Category.Core using (Category)"
] | src/Categories/Category/CMonoidEnriched.agda | CM-Category | |
Underlying : {o ℓ e : Level} → CM-Category o ℓ e → Category o ℓ e | function | src | [
"open import Level",
"open import Algebra.Bundles using (CommutativeMonoid)",
"open import Function.Base using (flip)",
"open import Relation.Binary using (Rel; IsEquivalence)",
"open import Categories.Category.Core using (Category)"
] | src/Categories/Category/CMonoidEnriched.agda | Underlying | |
BinaryCoproducts : Set (levelOfTerm 𝒞) where infixr 6 _+_ infixr 7 _+₁_ field coproduct : ∀ {A B} → Coproduct A B module coproduct {A} {B} = Coproduct (coproduct {A} {B}) _+_ : Obj → Obj → Obj A + B = coproduct.A+B {A} {B} open coproduct using (i₁; i₂; [_,_]; inject₁; inject₂; []-cong₂; ∘-distribˡ-[]) renaming (unique... | record | src | [
"open import Categories.Category.Core using (Category)",
"open import Level",
"open import Categories.Category.BinaryProducts using (BinaryProducts)",
"open import Categories.Category.Cartesian 𝒞.op",
"open import Categories.Category.Cartesian.Monoidal using (module CartesianMonoidal)",
"import Categorie... | src/Categories/Category/Cocartesian.agda | BinaryCoproducts | |
Cocartesian : Set (levelOfTerm 𝒞) where field initial : Initial coproducts : BinaryCoproducts module initial = Initial initial module coproducts = BinaryCoproducts coproducts open initial renaming (! to ¡; !-unique to ¡-unique; !-unique₂ to ¡-unique₂) public open coproducts hiding (module Dual) public module Dual wher... | record | src | [
"open import Categories.Category.Core using (Category)",
"open import Level",
"open import Categories.Category.BinaryProducts using (BinaryProducts)",
"open import Categories.Category.Cartesian 𝒞.op",
"open import Categories.Category.Cartesian.Monoidal using (module CartesianMonoidal)",
"import Categorie... | src/Categories/Category/Cocartesian.agda | Cocartesian | |
Cocomplete : (o ℓ e : Level) {o′ ℓ′ e′ : Level} (C : Category o′ ℓ′ e′) → Set _ | function | src | [
"open import Level",
"open import Categories.Category using (Category)",
"open import Categories.Functor using (Functor)",
"open import Categories.Diagram.Colimit using (Colimit)"
] | src/Categories/Category/Cocomplete.agda | Cocomplete | |
Complete : (o ℓ e : Level) {o′ ℓ′ e′ : Level} (C : Category o′ ℓ′ e′) → Set _ | function | src | [
"open import Level",
"open import Categories.Category",
"open import Categories.Category.Construction.Cones",
"open import Categories.Functor",
"open import Categories.Diagram.Cone.Properties",
"open import Categories.Diagram.Limit using (Limit)"
] | src/Categories/Category/Complete.agda | Complete | |
Concrete (C : Category o ℓ e) (ℓ′ e′ : Level) : Set (o ⊔ ℓ ⊔ e ⊔ suc (ℓ′ ⊔ e′)) where field concretize : Functor C (Setoids ℓ′ e′) conc-faithful : Faithful concretize -- Because of the use of the Hom functor, some levels collapse | record | src | [
"open import Level",
"open import Categories.Category.Core using (Category)",
"open import Categories.Category.Instance.Setoids using (Setoids)",
"open import Categories.Functor.Core using (Functor)",
"open import Categories.Functor.Representable using (Representable)",
"open import Categories.Functor.Pro... | src/Categories/Category/Concrete.agda | Concrete | |
RepresentablyConcrete (C : Category o ℓ e) : Set (o ⊔ suc (e ⊔ ℓ)) where open Concrete field conc : Concrete C ℓ e representable : Representable (concretize conc) | record | src | [
"open import Level",
"open import Categories.Category.Core using (Category)",
"open import Categories.Category.Instance.Setoids using (Setoids)",
"open import Categories.Functor.Core using (Functor)",
"open import Categories.Functor.Representable using (Representable)",
"open import Categories.Functor.Pro... | src/Categories/Category/Concrete.agda | RepresentablyConcrete | |
Category (o ℓ e : Level) : Set (suc (o ⊔ ℓ ⊔ e)) where eta-equality infix 4 _≈_ _⇒_ infixr 9 _∘_ field Obj : Set o _⇒_ : Rel Obj ℓ _≈_ : ∀ {A B} → Rel (A ⇒ B) e id : ∀ {A} → (A ⇒ A) _∘_ : ∀ {A B C} → (B ⇒ C) → (A ⇒ B) → (A ⇒ C) field assoc : ∀ {A B C D} {f : A ⇒ B} {g : B ⇒ C} {h : C ⇒ D} → (h ∘ g) ∘ f ≈ h ∘ (g ∘ f) --... | record | src | [
"open import Level",
"open import Function.Base using (flip)",
"open import Relation.Binary using (Rel; IsEquivalence; Setoid)",
"open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)",
"import Relation.Binary.Reasoning.Setoid as SetoidR"
] | src/Categories/Category/Core.agda | Category | |
HasDagger {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C infix 10 _† field _† : ∀ {A B} → A ⇒ B → B ⇒ A †-identity : ∀ {A} → id {A} † ≈ id †-homomorphism : ∀ {A B C} {f : A ⇒ B} {g : B ⇒ C} → (g ∘ f) † ≈ f † ∘ g † †-resp-≈ : ∀ {A B} {f g : A ⇒ B} → f ≈ g → f † ≈ g † †-involutive : ∀ {A B} (f : A ⇒... | record | src | [
"open import Level using (_⊔_; suc)",
"open import Relation.Unary using (Pred)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor.Core using (Functor)",
"open import Categories.Morphism using (Iso)"
] | src/Categories/Category/Dagger.agda | HasDagger | |
DaggerCategory o ℓ e : Set (suc (o ⊔ ℓ ⊔ e)) where field C : Category o ℓ e hasDagger : HasDagger C open Category C public open HasDagger hasDagger public | record | src | [
"open import Level using (_⊔_; suc)",
"open import Relation.Unary using (Pred)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor.Core using (Functor)",
"open import Categories.Morphism using (Iso)"
] | src/Categories/Category/Dagger.agda | DaggerCategory | |
IsDiscrete {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C using (Obj; _⇒_; _≈_) field isGroupoid : IsGroupoid C preorder : {A B : Obj} → (f g : A ⇒ B) → f ≈ g | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category using (Category)",
"open import Categories.Category.Groupoid using (IsGroupoid)"
] | src/Categories/Category/Discrete.agda | IsDiscrete | |
DiscreteCategory (o ℓ e : Level) : Set (suc (o ⊔ ℓ ⊔ e)) where field category : Category o ℓ e isDiscrete : IsDiscrete category open IsDiscrete isDiscrete public | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category using (Category)",
"open import Categories.Category.Groupoid using (IsGroupoid)"
] | src/Categories/Category/Discrete.agda | DiscreteCategory | |
Distributive : Set (levelOfTerm 𝒞) where field cartesian : Cartesian 𝒞 cocartesian : Cocartesian 𝒞 open Cartesian cartesian using (products) open BinaryProducts products open Cocartesian cocartesian distributeˡ : ∀ {A B C : Obj} → A × B + A × C ⇒ A × (B + C) distributeˡ = [ id ⁂ i₁ , id ⁂ i₂ ] field isIsoˡ : ∀ {A B ... | record | src | [
"open import Level using (levelOfTerm)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Category.Cartesian using (Cartesian)",
"open import Categories.Category.BinaryProducts using (BinaryProducts)",
"open import Categories.Category.Cocartesian using (Cocartesian)",
"impo... | src/Categories/Category/Distributive.agda | Distributive | |
WeakInverse (F : Functor C D) (G : Functor D C) : Set (levelOfTerm F ⊔ levelOfTerm G) where field F∘G≈id : NaturalIsomorphism (F ∘F G) idF G∘F≈id : NaturalIsomorphism (G ∘F F) idF module F∘G≈id = NaturalIsomorphism F∘G≈id module G∘F≈id = NaturalIsomorphism G∘F≈id | record | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | WeakInverse | |
StrongEquivalence {o ℓ e o′ ℓ′ e′} (C : Category o ℓ e) (D : Category o′ ℓ′ e′) : Set (o ⊔ ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) where field F : Functor C D G : Functor D C weak-inverse : WeakInverse F G open WeakInverse weak-inverse public op : StrongEquivalence (Category.op C) (Category.op D) op = record { F = Functor.op F ; G = Fun... | record | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | StrongEquivalence | |
refl : StrongEquivalence C C | function | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | refl | |
sym : StrongEquivalence C D → StrongEquivalence D C | function | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | sym | |
trans : StrongEquivalence C D → StrongEquivalence D E → StrongEquivalence C E | function | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | trans | |
isEquivalence : ∀ {o ℓ e} → IsEquivalence (StrongEquivalence {o} {ℓ} {e}) | function | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | isEquivalence | |
setoid : ∀ o ℓ e → Setoid _ _ | function | src | [
"open import Level",
"open import Relation.Binary using (IsEquivalence; Setoid)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Functor renaming (id to idF)",
"open import Categories.NaturalTransformation.NaturalIsomorphism as ≃"
] | src/Categories/Category/Equivalence.agda | setoid | |
Exact {o ℓ e : Level} (𝒞 : Category o ℓ e) : Set (suc (o ⊔ ℓ ⊔ e)) where open Category 𝒞 open Pullback open Coequalizer open Equivalence field regular : Regular 𝒞 quotient : ∀ {X : Obj} (E : Equivalence 𝒞 X) → Coequalizer 𝒞 (R.p₁ E) (R.p₂ E) effective : ∀ {X : Obj} (E : Equivalence 𝒞 X) → IsPullback 𝒞 (R.p₁ E) (... | record | src | [
"open import Level",
"open import Categories.Category.Core",
"open import Categories.Diagram.Pullback",
"open import Categories.Category.Cocartesian",
"open import Categories.Object.Coproduct",
"open import Categories.Morphism",
"open import Categories.Diagram.Coequalizer",
"open import Categories.Dia... | src/Categories/Category/Exact.agda | Exact | |
Extensive {o ℓ e : Level} (𝒞 : Category o ℓ e) : Set (suc (o ⊔ ℓ ⊔ e)) where open Category 𝒞 open Pullback using (p₁) field cocartesian : Cocartesian 𝒞 module CC = Cocartesian cocartesian open CC using (_+_; i₁; i₂; ¡) field pullback₁ : {A B C : Obj} (f : A ⇒ B + C) → Pullback 𝒞 f i₁ pullback₂ : {A B C : Obj} (f : ... | record | src | [
"open import Level",
"open import Function using (_$_)",
"open import Categories.Category.Core using (Category)",
"open import Categories.Diagram.Pullback using (Pullback; IsPullback; up-to-iso)",
"open import Categories.Diagram.Pullback.Properties using (module IsoPb)",
"open import Categories.Category.C... | src/Categories/Category/Extensive.agda | Extensive | |
Finite {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where field shape : FinCatShape open FinCatShape public renaming (size to ∣Obj∣) shapeCat : Category _ _ _ shapeCat = FinCategory shape -- -- /------------\ -- < - \ -- C | S -- \ - ^ -- \------------/ -- field ⊣equiv : ⊣Equivalence shapeCat C module ⊣equiv = ⊣Equiv... | record | src | [
"open import Level",
"open import Categories.Adjoint.Equivalence",
"open import Categories.Category.Core",
"open import Categories.Category.Finite.Fin"
] | src/Categories/Category/Finite.agda | Finite | |
IsGroupoid {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C public open Definitions C public open Categories.Morphism C infix 10 _⁻¹ field _⁻¹ : ∀ {A B} → A ⇒ B → B ⇒ A iso : ∀ {A B} {f : A ⇒ B} → Iso f (f ⁻¹) module iso {A B f} = Iso (iso {A} {B} {f}) equiv-obj : ∀ {A B} → A ⇒ B → A ≅ B equiv-obj f... | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category",
"import Categories.Morphism"
] | src/Categories/Category/Groupoid.agda | IsGroupoid | |
Groupoid (o ℓ e : Level) : Set (suc (o ⊔ ℓ ⊔ e)) where field category : Category o ℓ e isGroupoid : IsGroupoid category open IsGroupoid isGroupoid public | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category",
"import Categories.Morphism"
] | src/Categories/Category/Groupoid.agda | Groupoid | |
categoryHelper : ∀ {o ℓ e} → CategoryHelper o ℓ e → Category o ℓ e | function | src | [
"open import Level",
"open import Relation.Binary using (Rel; IsEquivalence)",
"open import Categories.Category.Core using (Category)"
] | src/Categories/Category/Helper.agda | categoryHelper | |
Indiscrete : ∀ {o ℓ} (A : Set o) → Category o ℓ ℓ | function | src | [
"open import Level",
"open import Data.Unit",
"open import Categories.Category",
"open import Relation.Binary.PropositionalEquality as ≡"
] | src/Categories/Category/Indiscrete.agda | Indiscrete | |
pseudo-iso {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C open Definitions C open Categories.Morphism C infix 10 _⁻¹ field _⁻¹ : ∀ {A B} → (f : A ⇒ B) → B ⇒ A pseudo-iso₁ : ∀ {A B} {f : A ⇒ B} → f ∘ f ⁻¹ ∘ f ≈ f pseudo-iso₂ : ∀ {A B} {f : A ⇒ B} → f ⁻¹ ∘ f ∘ f ⁻¹ ≈ f ⁻¹ | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category",
"open import Data.Product",
"import Categories.Morphism"
] | src/Categories/Category/Inverse.agda | pseudo-iso | |
Inverse {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C open Definitions C open Categories.Morphism C open pseudo-iso field piso : pseudo-iso C unique : ∀ {p : pseudo-iso C} {A B} → (f : A ⇒ B) → _⁻¹ piso f ≈ _⁻¹ p f | record | src | [
"open import Level using (Level; suc; _⊔_)",
"open import Categories.Category",
"open import Data.Product",
"import Categories.Morphism"
] | src/Categories/Category/Inverse.agda | Inverse | |
liftC : ∀ {o ℓ e} o′ ℓ′ e′ → Category o ℓ e → Category (o ⊔ o′) (ℓ ⊔ ℓ′) (e ⊔ e′) | function | src | [
"open import Level",
"open import Categories.Category",
"open import Categories.Functor using (Functor)"
] | src/Categories/Category/Lift.agda | liftC | |
liftF : ∀ {o ℓ e} o′ ℓ′ e′ (C : Category o ℓ e) → Functor C (liftC o′ ℓ′ e′ C) | function | src | [
"open import Level",
"open import Categories.Category",
"open import Categories.Functor using (Functor)"
] | src/Categories/Category/Lift.agda | liftF | |
unliftF : ∀ {o ℓ e} o′ ℓ′ e′ (C : Category o ℓ e) → Functor (liftC o′ ℓ′ e′ C) C | function | src | [
"open import Level",
"open import Categories.Category",
"open import Categories.Functor using (Functor)"
] | src/Categories/Category/Lift.agda | unliftF | |
Product : (C : Category o ℓ e) (D : Category o′ ℓ′ e′) → Category (o ⊔ o′) (ℓ ⊔ ℓ′) (e ⊔ e′) | function | src | [
"open import Level",
"open import Function using () renaming (_∘_ to _∙_)",
"open import Data.Product using (_×_; Σ; _,_; proj₁; proj₂; zip; map; <_,_>; swap)",
"open import Categories.Utils.Product",
"open import Categories.Category using (Category)",
"open import Categories.Category.Groupoid using (IsGr... | src/Categories/Category/Product.agda | Product | |
Regular {o ℓ e : Level} (𝒞 : Category o ℓ e) : Set (suc (o ⊔ ℓ ⊔ e)) where open Category 𝒞 open Pullback field finitely-complete : FinitelyComplete 𝒞 coeq-of-kernelpairs : {A B : Obj} (f : A ⇒ B) (kp : KernelPair 𝒞 f) → Coequalizer 𝒞 (p₁ kp) (p₂ kp) pullback-of-regularepi-is-regularepi : {A B C : Obj} (f : B ⇒ A) ... | record | src | [
"open import Level",
"open import Categories.Category.Core",
"open import Categories.Category.Complete.Finitely using (FinitelyComplete)",
"open import Categories.Diagram.Coequalizer",
"open import Categories.Diagram.KernelPair",
"open import Categories.Diagram.Pullback",
"open import Categories.Morphis... | src/Categories/Category/Regular.agda | Regular | |
Restriction (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where open Category C using (Obj; _⇒_; _∘_; _≈_; id) field _↓ : {A B : Obj} → A ⇒ B → A ⇒ A -- partial identity on the right pidʳ : {A B : Obj} {f : A ⇒ B} → f ∘ f ↓ ≈ f -- the domain-of-definition arrows commute ↓-comm : {A B C : Obj} {f : A ⇒ B} {g : A ⇒ C} → f ↓ ∘ g... | record | src | [
"open import Level using (Level; _⊔_)",
"open import Categories.Category.Core using (Category)"
] | src/Categories/Category/Restriction.agda | Restriction | |
RigCategory {M⊎ M× : Monoidal C} (S⊎ : Symmetric M⊎) (S× : Symmetric M×) : Set (o ⊔ ℓ ⊔ e) where open Commutation C open Definitions C module M⊎ = Monoidal M⊎ module M× = Monoidal M× module S⊎ = Symmetric S⊎ module S× = Symmetric S× open M⊎ renaming (_⊗₀_ to _⊕₀_; _⊗₁_ to _⊕₁_) open M× private 0C : C.Obj 0C = M⊎.unit 1... | record | src | [
"open import Categories.Category",
"open import Level",
"open import Data.Fin.Base using () renaming (zero to 0F; suc to sucF)",
"open import Data.Product using (_,_)",
"open import Categories.Functor.Core",
"open import Categories.Category.Monoidal",
"open import Categories.Category.Monoidal.Braided",
... | src/Categories/Category/RigCategory.agda | RigCategory | |
Coverage {i} j {I : Obj → Set i} (covering₀ : ∀ {X} → I X → Obj) (covering₁ : ∀ {X} (i : I X) → covering₀ i ⇒ X) : Set (i ⊔ suc j ⊔ o ⊔ ℓ ⊔ e) where field J : ∀ (g : Y ⇒ Z) → Set j universal₀ : ∀ {g : Y ⇒ Z} → J g → Obj universal₁ : ∀ {g : Y ⇒ Z} (j : J g) → universal₀ j ⇒ Y commute : ∀ {g : Y ⇒ Z} (j : J g) → ∃₂ (λ i ... | record | src | [
"open import Categories.Category",
"open import Level",
"open import Data.Product using (Σ; _,_; ∃₂)"
] | src/Categories/Category/Site.agda | Coverage | |
Site i j : Set (suc i ⊔ suc j ⊔ o ⊔ ℓ ⊔ e) where field I : Obj → Set i covering₀ : ∀ {X} → I X → Obj covering₁ : ∀ {X} (i : I X) → covering₀ i ⇒ X coverage : Coverage j covering₀ covering₁ module coverage = Coverage coverage open coverage public | record | src | [
"open import Categories.Category",
"open import Level",
"open import Data.Product using (Σ; _,_; ∃₂)"
] | src/Categories/Category/Site.agda | Site | |
SliceObj (X : Obj) : Set (o ⊔ ℓ) where constructor sliceobj field {Y} : Obj arr : Y ⇒ X private variable A : Obj X Y Z : SliceObj A | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary.Core using (Rel)",
"open import Categories.Morphism.Reasoning 𝒞"
] | src/Categories/Category/Slice.agda | SliceObj | |
Slice ⇒ {A : Obj} (X Y : SliceObj A) : Set (ℓ ⊔ e) where constructor slicearr private module X = SliceObj X module Y = SliceObj Y field {h} : X.Y ⇒ Y.Y △ : Y.arr ∘ h ≈ X.arr Slice : Obj → Category _ _ _ Slice A = record { Obj = SliceObj A ; _⇒_ = Slice⇒ ; _≈_ = λ where (slicearr {f} _) (slicearr {g} _) → f ≈ g ; id = s... | record | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary.Core using (Rel)",
"open import Categories.Morphism.Reasoning 𝒞"
] | src/Categories/Category/Slice.agda | Slice | |
Slice : Obj → Category _ _ _ | function | src | [
"open import Categories.Category.Core",
"open import Level",
"open import Relation.Binary.Core using (Rel)",
"open import Categories.Morphism.Reasoning 𝒞"
] | src/Categories/Category/Slice.agda | Slice | |
Species : (o ℓ o′ ℓ′ : Level) → Category (suc (o ⊔ ℓ ⊔ o′ ⊔ ℓ′)) (suc (o ⊔ ℓ) ⊔ (o′ ⊔ ℓ′)) (suc (o ⊔ ℓ) ⊔ o′ ⊔ ℓ′) | function | src | [
"open import Level",
"open import Categories.Category.Core using (Category)",
"open import Categories.Category.Construction.Functors",
"open import Categories.Category.Construction.Core using (Core)",
"open import Categories.Category.Instance.FinSetoids using (FinSetoids)",
"open import Categories.Categor... | src/Categories/Category/Species.agda | Species | |
SubCat (I : Set i) : Set (o ⊔ ℓ ⊔ i ⊔ suc ℓ′) where field U : I → Obj R : {a b : I} → U a ⇒ U b → Set ℓ′ Rid : {a : I} → R (id {U a}) _∘R_ : {a b c : I} {f : U b ⇒ U c} {g : U a ⇒ U b} → R f → R g → R (f ∘ g) SubCategory : SubCat {ℓ′ = ℓ′} I → Category _ _ _ SubCategory {I = I} sc = let open SubCat sc in record { Obj =... | record | src | [
"open import Categories.Category",
"open import Level",
"open import Data.Product"
] | src/Categories/Category/SubCategory.agda | SubCat | |
SubCategory : SubCat {ℓ′ = ℓ′} I → Category _ _ _ | function | src | [
"open import Categories.Category",
"open import Level",
"open import Data.Product"
] | src/Categories/Category/SubCategory.agda | SubCategory |
End of preview. Expand in Data Studio
Agda-Categories
Structured dataset from agda-categories — Category theory.
730 declarations extracted from Agda source files.
Applications
- Training language models on formal proofs
- Fine-tuning theorem provers
- Retrieval-augmented generation for proof assistants
- Learning proof embeddings and representations
Source
- Repository: https://github.com/agda/agda-categories
Schema
| Column | Type | Description |
|---|---|---|
| fact | string | Declaration body |
| type | string | data, record, function |
| library | string | Source module |
| imports | list | Required imports |
| filename | string | Source file path |
| symbolic_name | string | Identifier |
- Downloads last month
- 8