statement stringlengths 7 7.82k | proof stringlengths 0 7.11k | type stringclasses 4
values | symbolic_name stringlengths 1 43 | library stringclasses 37
values | filename stringclasses 238
values | imports listlengths 0 20 | deps listlengths 0 35 | docstring stringclasses 1
value | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
i1 ∘ise i2 = snd ((_ , i1) ∘e (_ , i2)) | function | i1 | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
(_ , ise) ⁻¹ = (is-equiv.g ise , is-equiv-inverse ise)
{- Equational reasoning for equivalences -} | function | _ | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [
"is-equiv-inverse"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
X ⊙≃ Y = Σ (X ⊙→ Y) (λ {(f , _) → is-equiv f}) | X ⊙≃⟨ u ⟩ v = v ⊙∘e u | function | X | 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 | |
(g , g-eq) ⊙∘e (f , f-eq) = (g ⊙∘ f , g-eq ∘ise f-eq) | function | g | core.lib | core/lib/Equivalence.agda | [
"lib.Base",
"lib.NType",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Function"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
is-contr-map : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
→ Type (lmax i j) | is-contr-map {A = A} {B = B} f = (y : B) → is-contr (hfiber f y) | function | is-contr-map | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"hfiber",
"is-contr"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
equiv-is-contr-map : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
→ (is-equiv f → is-contr-map f) | equiv-is-contr-map e y =
equiv-preserves-level (Σ-emap-l (_== y) (_ , e) ⁻¹) | function | equiv-is-contr-map | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"is-contr-map",
"is-equiv",
"Σ-emap-l"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
contr-map-is-equiv : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
→ (is-contr-map f → is-equiv f) | contr-map-is-equiv {f = f} cm = is-eq _
(λ b → fst (contr-center (cm b)))
(λ b → snd (contr-center (cm b)))
(λ a → ap fst (contr-path (cm (f a)) (a , idp))) | function | contr-map-is-equiv | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"ap",
"fst",
"idp",
"is-contr-map",
"is-equiv",
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
equiv-rcoh-is-contr : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
(e : is-equiv f) → (v : rinv f) → is-contr (rcoh f v) | equiv-rcoh-is-contr {f = f} e v = equiv-preserves-level ((rcoh-econv v)⁻¹)
{{Π-level (λ x → =-preserves-level (equiv-is-contr-map e (f x)))}} | function | equiv-rcoh-is-contr | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"equiv-is-contr-map",
"is-contr",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
rinv-and-rcoh-is-equiv : ∀ {i j} {A : Type i} {B : Type j} {h : A → B}
→ Σ (rinv h) (rcoh h) ≃ is-equiv h | rinv-and-rcoh-is-equiv {h = h} = equiv f g (λ _ → idp) (λ _ → idp)
where f : Σ (rinv h) (rcoh h) → is-equiv h
f s = record {g = fst (fst s); f-g = snd (fst s);
g-f = fst (snd s); adj = snd (snd s)}
g : is-equiv h → Σ (rinv h) (rcoh h)
g t = ((is-equiv.g t , is-equiv.f-g t... | function | rinv-and-rcoh-is-equiv | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"fst",
"idp",
"is-equiv",
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-equiv-is-prop : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
→ is-prop (is-equiv f) | is-equiv-is-prop = inhab-to-contr-is-prop λ e →
equiv-preserves-level rinv-and-rcoh-is-equiv
{{Σ-level (equiv-rinv-is-contr e) (equiv-rcoh-is-contr e)}} | function | is-equiv-is-prop | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"equiv-rcoh-is-contr",
"is-equiv",
"is-prop",
"rinv-and-rcoh-is-equiv",
"Σ-level"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-equiv-level : ∀ {i j} {A : Type i} {B : Type j} {f : A → B} {n : ℕ₋₂}
→ has-level (S n) (is-equiv f) | is-equiv-level = prop-has-level-S is-equiv-is-prop | function | is-equiv-level | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"is-equiv",
"is-equiv-is-prop",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-equiv-prop : ∀ {i j} {A : Type i} {B : Type j}
→ SubtypeProp (A → B) (lmax i j) | is-equiv-prop = is-equiv , λ f → is-equiv-is-prop | function | is-equiv-prop | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"is-equiv",
"is-equiv-is-prop"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
∘e-unit-r : ∀ {i} {A B : Type i} (e : A ≃ B) → (e ∘e ide A) == e | ∘e-unit-r e = pair= idp (prop-has-all-paths _ _) | function | ∘e-unit-r | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"ide",
"idp",
"pair="
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ua-∘e : ∀ {i} {A B : Type i}
(e₁ : A ≃ B) {C : Type i} (e₂ : B ≃ C) → ua (e₂ ∘e e₁) == ua e₁ ∙ ua e₂ | ua-∘e =
equiv-induction
(λ {A} {B} e₁ → ∀ {C} → ∀ (e₂ : B ≃ C) → ua (e₂ ∘e e₁) == ua e₁ ∙ ua e₂)
(λ A → λ e₂ → ap ua (∘e-unit-r e₂) ∙ ap (λ w → (w ∙ ua e₂)) (! (ua-η idp)))
{- Adjointion where hom = path -} | function | ua-∘e | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"ap",
"equiv-induction",
"idp",
"ua",
"ua-η",
"∘e-unit-r"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Σ₂-Empty : ∀ {i} {A : Type i} → Σ A (λ _ → Empty) ≃ Empty | Σ₂-Empty = equiv (⊥-rec ∘ snd) ⊥-rec ⊥-elim (⊥-rec ∘ snd)
{- Fiberwise equivalence -} | function | Σ₂-Empty | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Empty",
"Type",
"snd",
"⊥-elim",
"⊥-rec"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
replace-inverse : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
(f-ise : is-equiv f) {g₁ : B → A}
→ is-equiv.g f-ise ∼ g₁ → is-equiv f | replace-inverse {f = f} f-ise {g₁ = g₁} g∼ =
is-eq f g₁ (λ b → ap f (! (g∼ b)) ∙ f-g b) (λ a → ! (g∼ (f a)) ∙ g-f a)
where open is-equiv f-ise | function | replace-inverse | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"ap",
"is-equiv"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
fiber=-econv : ∀ {i j} {A : Type i} {B : Type j} {h : A → B} {y : B}
(r s : Σ A (λ x → h x == y))
→ (r == s) ≃ Σ (fst r == fst s) (λ γ → ap h γ ∙ snd s == snd r) | fiber=-econv r s = Σ-emap-r (λ γ → !-equiv ∘e (↓-app=cst-econv ⁻¹)) ∘e ((=Σ-econv r s)⁻¹) | function | fiber=-econv | core.lib | core/lib/Equivalence2.agda | [
"lib.Basics",
"lib.types.Sigma",
"lib.types.Pi",
"lib.types.Paths",
"lib.types.Unit",
"lib.types.Empty"
] | [
"Type",
"ap",
"fst",
"snd",
"Σ-emap-r"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
CommSquare {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₁)) where
constructor comm-sqr
field
commutes : hB ∘ f₀ ∼ f₁ ∘ hA | record | CommSquare | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
⊙CommSquare {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₁)) where
constructor ⊙comm-sqr
field
⊙commutes : hY ⊙∘ f₀ ⊙∼ f₁ ⊙∘ hX | record | ⊙CommSquare | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Ptd",
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
⊙∘-pt : ∀ {i j} {A : Type i} {B : Type j}
{a₁ a₂ : A} (f : A → B) {b : B}
→ a₁ == a₂ → f a₂ == b → f a₁ == b | ⊙∘-pt f p q = ap f p ∙ q | function | ⊙∘-pt | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"a₁"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_∼_ : ∀ {i j} {A : Type i} {B : A → Type j}
(f g : (a : A) → B a) → Type (lmax i j) | function | _∼_ | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
_⊙∼_ : ∀ {i j} {X : Ptd i} {Y : Ptd j}
(f g : X ⊙→ Y) → Type (lmax i j) | _⊙∼_ {X = X} {Y = Y} (f , f-pt) (g , g-pt) =
Σ (f ∼ g) λ p → f-pt == g-pt [ (_== pt Y) ↓ p (pt X) ]
{-
infixr 80 _⊙∼-∙_
_⊙∼-∙_ : ∀ {i j} {X : Ptd i} {Y : Ptd j} {f g h : X ⊙→ Y}
→ f ⊙∼ g → g ⊙∼ h → f ⊙∼ h
_⊙∼-∙_ f∼g g∼h = fst f∼g ∼-∙ fst g∼h , snd f∼g ∙ᵈ snd g∼h
⊙∼-! : ∀ {i j} {X : Ptd i} {Y : Ptd j} {f g : X ⊙→... | function | _⊙∼_ | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Ptd",
"Type",
"pt"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_⊙∘_ : ∀ {i j k} {X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(g : Y ⊙→ Z) (f : X ⊙→ Y) → X ⊙→ Z | function | _⊙∘_ | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Ptd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
⊙∘-unit-l : ∀ {i j} {X : Ptd i} {Y : Ptd j} (f : X ⊙→ Y)
→ ⊙idf Y ⊙∘ f ⊙∼ f | ⊙∘-unit-l (f , idp) = (λ _ → idp) , idp | function | ⊙∘-unit-l | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Ptd",
"idp",
"⊙idf"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
⊙∘-unit-r : ∀ {i j} {X : Ptd i} {Y : Ptd j} (f : X ⊙→ Y)
→ f ⊙∘ ⊙idf X ⊙∼ f | ⊙∘-unit-r f = (λ _ → idp) , idp
{- Homotopy fibers -} | function | ⊙∘-unit-r | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Ptd",
"idp",
"⊙idf"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
f ∼ g = ∀ x → f x == g x
{-
infixr 80 _∼-∙_
_∼-∙_ : ∀ {i j} {A : Type i} {B : Type j} {f g h : A → B}
→ f ∼ g → g ∼ h → f ∼ h
_∼-∙_ f∼g g∼h x = f∼g x ∙ g∼h x
∼-! : ∀ {i j} {A : Type i} {B : Type j} {f g : A → B}
→ f ∼ g → g ∼ f
∼-! f∼g = ! ∘ f∼g
-} | function | f | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
(g , gpt) ⊙∘ (f , fpt) = (g ∘ f) , ⊙∘-pt g fpt gpt | function | g | core.lib | core/lib/Function.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"⊙∘-pt"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
is-surj : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) → Type (lmax i j) | is-surj {A = A} f = ∀ b → Trunc -1 (hfiber f b) | function | is-surj | core.lib | core/lib/Function2.agda | [
"lib.Basics",
"lib.types.Truncation"
] | [
"Type",
"hfiber"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-connected : ∀ {i} → ℕ₋₂ → Type i → Type i | is-connected n A = is-contr (Trunc n A) | function | is-connected | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-contr",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
has-conn-fibers : ∀ {i j} {A : Type i} {B : Type j} → ℕ₋₂ → (A → B) → Type (lmax i j) | has-conn-fibers {A = A} {B = B} n f =
Π B (λ b → is-connected n (hfiber f b))
{- all types are -2-connected -} | function | has-conn-fibers | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"hfiber",
"is-connected",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
-2-conn : ∀ {i} (A : Type i) → is-connected -2 A | -2-conn A = Trunc-level
{- all inhabited types are -1-connected -} | function | -2-conn | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-connected"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
inhab-conn : ∀ {i} {A : Type i} (a : A) → is-connected -1 A | inhab-conn a = has-level-in ([ a ] , prop-has-all-paths [ a ])
{- connectedness is a prop -} | function | inhab-conn | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-connected"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-connected-is-prop : ∀ {i} {n : ℕ₋₂} {A : Type i}
→ is-prop (is-connected n A) | is-connected-is-prop = is-contr-is-prop
{- "induction principle" for n-connected maps (where codomain is n-type) -} | function | is-connected-is-prop | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-connected",
"is-prop",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
conn-extend-general : ∀ {i j} {A : Type i} {B : Type j} {n k : ℕ₋₂}
→ {f : A → B} → has-conn-fibers n f
→ ∀ {l} (P : B → (k +2+ n) -Type l)
→ ∀ t → has-level k (Σ (Π B (fst ∘ P)) (λ s → (s ∘ f) == t)) | conn-extend-general {k = ⟨-2⟩} c P t =
equiv-is-contr-map (pre∘-conn-is-equiv c P) t
conn-extend-general {B = B} {n = n} {k = S k'} {f = f} c P t = has-level-in
λ {(g , p) (h , q) →
equiv-preserves-level (e g h p q)
{{conn-extend-general {k = k'} c (Q g h) (app= (p ∙ ! q))}} }
where
Q : (g h : Π B (... | function | conn-extend-general | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"ap",
"equiv-is-contr-map",
"fst",
"has-conn-fibers",
"idp",
"lemma",
"snd",
"transport",
"Σ-emap-l",
"Σ-emap-r",
"ℕ₋₂",
"⟨-2⟩"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
conn-in : ∀ {i j} {A : Type i} {B : Type j} {n : ℕ₋₂} {h : A → B}
→ (∀ (P : B → n -Type (lmax i j))
→ Σ (Π A (fst ∘ P ∘ h) → Π B (fst ∘ P))
(λ u → ∀ (t : Π A (fst ∘ P ∘ h)) → u t ∘ h ∼ t))
→ has-conn-fibers n h | conn-in {A = A} {B = B} {h = h} sec b =
let s = sec (λ b → (Trunc _ (hfiber h b) , Trunc-level))
in has-level-in (fst s (λ a → [ a , idp ]) b ,
Trunc-elim (λ k → transport
(λ v → fst s (λ a → [ a , idp ]) (fst v) == [ fst k , snd v ])
(contr-path (pathfrom-is-contr (h (fs... | function | conn-in | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"fst",
"has-conn-fibers",
"hfiber",
"idp",
"snd",
"transport",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
pointed-conn-in : ∀ {i} {n : ℕ₋₂} (A : Type i) (a₀ : A)
→ has-conn-fibers {A = ⊤} n (cst a₀) → is-connected (S n) A | pointed-conn-in {n = n} A a₀ c = has-level-in
([ a₀ ] ,
Trunc-elim
(λ a → Trunc-rec
(λ x → ap [_] (snd x)) (contr-center $ c a))) | function | pointed-conn-in | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"[_]",
"ap",
"cst",
"has-conn-fibers",
"is-connected",
"snd",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
pointed-conn-out : ∀ {i} {n : ℕ₋₂} (A : Type i) (a₀ : A)
{{_ : is-connected (S n) A}} → has-conn-fibers {A = ⊤} n (cst a₀) | pointed-conn-out {n = n} A a₀ {{c}} a = has-level-in
(point ,
λ y → ! (cancel point)
∙ (ap out $ contr-has-all-paths (into point) (into y))
∙ cancel y)
where
into-aux : Trunc n (Σ ⊤ (λ _ → a₀ == a)) → Trunc n (a₀ == a)
into-aux = Trunc-fmap snd
into : Trunc n (Σ ⊤ (... | function | pointed-conn-out | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Trunc-fmap",
"Trunc-fmap-∘",
"Type",
"[_]",
"ap",
"cancel",
"cst",
"has-conn-fibers",
"idp",
"into",
"is-connected",
"out",
"snd",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
prop-over-connected : ∀ {i j} {A : Type i} {a : A} {{p : is-connected 0 A}}
→ (P : A → hProp j)
→ fst (P a) → Π A (fst ∘ P) | prop-over-connected P x = conn-extend (pointed-conn-out _ _) P (λ _ → x)
{- Connectedness of a truncated type -} | function | prop-over-connected | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"fst",
"hProp",
"is-connected",
"pointed-conn-out"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
connected-at-level-is-contr : ∀ {i} {A : Type i} {n : ℕ₋₂}
{{pA : has-level n A}} {{cA : is-connected n A}} → is-contr A | connected-at-level-is-contr {{pA}} {{cA}} =
equiv-preserves-level (unTrunc-equiv _) {{cA}}
{- if A is n-connected and m ≤ n, then A is m-connected -} | function | connected-at-level-is-contr | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-connected",
"is-contr",
"unTrunc-equiv",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
connected-≤T : ∀ {i} {m n : ℕ₋₂} {A : Type i}
→ m ≤T n → {{_ : is-connected n A}} → is-connected m A | connected-≤T {m = m} {n = n} {A = A} leq =
transport is-contr (ua (Trunc-fuse-≤ A leq)) (Trunc-preserves-level m ⟨⟩)
{- Equivalent types have the same connectedness -} | function | connected-≤T | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Trunc-fuse-≤",
"Trunc-preserves-level",
"Type",
"is-connected",
"is-contr",
"transport",
"ua",
"ℕ₋₂",
"⟨⟩"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
equiv-preserves-conn : ∀ {i j} {A : Type i} {B : Type j} {n : ℕ₋₂} (e : A ≃ B)
{{_ : is-connected n A}} → is-connected n B | equiv-preserves-conn {n = n} e = equiv-preserves-level (Trunc-emap e) | function | equiv-preserves-conn | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"is-connected",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
trunc-proj-conn : ∀ {i} (A : Type i) (n : ℕ₋₂)
→ has-conn-fibers n ([_] {n = n} {A = A}) | trunc-proj-conn A n =
conn-in $ λ P →
Trunc-elim {P = fst ∘ P} {{snd ∘ P}} , λ t a → idp
{- Composite of two connected functions is connected -} | function | trunc-proj-conn | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"[_]",
"conn-in",
"fst",
"has-conn-fibers",
"idp",
"snd",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
∘-conn : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k}
→ {n : ℕ₋₂} → (f : A → B) → (g : B → C)
→ has-conn-fibers n f
→ has-conn-fibers n g
→ has-conn-fibers n (g ∘ f) | ∘-conn {n = n} f g cf cg =
conn-in (λ P → conn-extend cg P ∘ conn-extend cf (P ∘ g) , lemma P)
where
lemma : ∀ P h x → conn-extend cg P (conn-extend cf (P ∘ g) h) (g (f x)) == h x
lemma P h x =
conn-extend cg P (conn-extend cf (P ∘ g) h) (g (f x))
=⟨ conn-extend-β cg P (conn-extend c... | function | ∘-conn | core.lib | core/lib/NConnected.agda | [
"lib.Basics",
"lib.NType2",
"lib.Equivalence2",
"lib.path-seq.Rotations",
"lib.types.Unit",
"lib.types.Nat",
"lib.types.Pi",
"lib.types.Pointed",
"lib.types.Sigma",
"lib.types.Paths",
"lib.types.TLevel",
"lib.types.Truncation"
] | [
"Type",
"conn-in",
"has-conn-fibers",
"lemma",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
is-gpd : {i : ULevel} → Type i → Type i | is-gpd = has-level 1
-- Type of all n-truncated types
-- TODO: redefine it like that, so that instance arguments can work
-- record _-Type_ (n : ℕ₋₂) (i : ULevel) : Type (lsucc i) where
-- constructor _,_
-- field
-- El : Type i
-- {{El-level}} : has-level n El
-- open _-Type_ public | function | is-gpd | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
has-level-prop : ∀ {i} → ℕ₋₂ → SubtypeProp (Type i) i | has-level-prop n = has-level n , λ _ → has-level-is-prop | function | has-level-prop | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_-Type_ : (n : ℕ₋₂) (i : ULevel) → Type (lsucc i) | function | _-Type_ | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
hProp : (i : ULevel) → Type (lsucc i) | hProp i = -1 -Type i | function | hProp | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
hSet : (i : ULevel) → Type (lsucc i) | hSet i = 0 -Type i | function | hSet | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_-Type₀ : (n : ℕ₋₂) → Type₁ | function | _-Type₀ | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type₁",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
≃-contr : ∀ {i j} {A : Type i} {B : Type j}
→ is-contr A → is-contr B → is-contr (A ≃ B) | ≃-contr pA pB = has-level-in
((cst (contr-center pB) , contr-to-contr-is-equiv _ pA pB)
, (λ e → pair= (λ= (λ _ → contr-path pB _))
(from-transp is-equiv _ (prop-path is-equiv-is-prop _ _)))) | function | ≃-contr | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"cst",
"is-contr",
"is-equiv",
"is-equiv-is-prop",
"pair="
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
≃-level : ∀ {i j} {n : ℕ₋₂} {A : Type i} {B : Type j}
→ (has-level n A → has-level n B → has-level n (A ≃ B)) | ≃-level {n = ⟨-2⟩} = ≃-contr
≃-level {n = S n} pA pB = Σ-level ⟨⟩ ⟨⟩ where instance _ = pA; _ = pB | function | ≃-level | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"Σ-level",
"ℕ₋₂",
"≃-contr",
"⟨-2⟩",
"⟨⟩"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
_-Type-level_ : (n : ℕ₋₂) (i : ULevel)
→ has-level (S n) (n -Type i) | function | _-Type-level_ | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
hProp-is-set : (i : ULevel) → is-set (hProp i) | hProp-is-set i = -1 -Type-level i | function | hProp-is-set | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"hProp",
"is-set"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
hSet-level : (i : ULevel) → has-level 1 (hSet i) | hSet-level i = 0 -Type-level i
{- The following two lemmas are in NType2 instead of NType because of cyclic
dependencies -} | function | hSet-level | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"hSet"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
n -Type i = Subtype (has-level-prop {i} n) | n -Type₀ = n -Type lzero
(n -Type-level i) = has-level-in (λ { (A , pA) (B , pB) → aux A B pA pB}) where
aux : (A B : Type i) (pA : has-level n A) (pB : has-level n B) → has-level n ((A , pA) == (B , pB))
aux A B pA pB = equiv-preserves-level (nType=-econv (A , ⟨⟩) (B , ⟨⟩)) where instance _ = pA; _ = pB | function | n | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"has-level-prop",
"⟨⟩"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
hProp₀ = hProp lzero | function | hProp₀ | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"hProp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
hSet₀ = hSet lzero
-- [n -Type] is an (n+1)-type | function | hSet₀ | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"hSet"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
universe-=-level : ∀ {i} {n : ℕ₋₂} {A B : Type i}
→ (has-level n A → has-level n B → has-level n (A == B)) | universe-=-level pA pB = equiv-preserves-level ua-equiv where instance _ = pA; _ = pB | function | universe-=-level | core.lib | core/lib/NType2.agda | [
"lib.Basics",
"lib.Equivalence2",
"lib.Relation2",
"lib.types.Paths",
"lib.types.Pi",
"lib.types.Sigma",
"lib.types.TLevel"
] | [
"Type",
"ua-equiv",
"ℕ₋₂"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ap-idf : ∀ {i} {A : Type i} {u v : A} (p : u == v) → ap (idf A) p == p | ap-idf idp = idp
{- Functoriality of [coe] -} | function | ap-idf | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"idf",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-∙ : ∀ {i} {A B C : Type i} (p : A == B) (q : B == C) (a : A)
→ coe (p ∙ q) a == coe q (coe p a) | coe-∙ idp q a = idp | function | coe-∙ | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"coe",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-! : ∀ {i} {A B : Type i} (p : A == B) (b : B) → coe (! p) b == coe! p b | coe-! idp b = idp | function | coe-! | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"coe",
"coe!",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe!-inv-r : ∀ {i} {A B : Type i} (p : A == B) (b : B)
→ coe p (coe! p b) == b | coe!-inv-r idp b = idp | function | coe!-inv-r | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"coe",
"coe!",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe!-inv-l : ∀ {i} {A B : Type i} (p : A == B) (a : A)
→ coe! p (coe p a) == a | coe!-inv-l idp a = idp | function | coe!-inv-l | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"coe",
"coe!",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-inv-adj : ∀ {i} {A B : Type i} (p : A == B) (a : A) →
ap (coe p) (coe!-inv-l p a) == coe!-inv-r p (coe p a) | coe-inv-adj idp a = idp | function | coe-inv-adj | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"coe",
"coe!-inv-l",
"coe!-inv-r",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe!-inv-adj : ∀ {i} {A B : Type i} (p : A == B) (b : B) →
ap (coe! p) (coe!-inv-r p b) == coe!-inv-l p (coe! p b) | coe!-inv-adj idp b = idp | function | coe!-inv-adj | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"coe!",
"coe!-inv-l",
"coe!-inv-r",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-ap-! : ∀ {i j} {A : Type i} (P : A → Type j) {a b : A} (p : a == b)
(x : P b)
→ coe (ap P (! p)) x == coe! (ap P p) x | coe-ap-! P idp x = idp
{- Functoriality of transport -} | function | coe-ap-! | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"coe",
"coe!",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-∙ : ∀ {i j} {A : Type i} {B : A → Type j} {x y z : A}
(p : x == y) (q : y == z) (b : B x)
→ transport B (p ∙ q) b == transport B q (transport B p b) | transp-∙ idp _ _ = idp | function | transp-∙ | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-∙' : ∀ {i j} {A : Type i} {B : A → Type j} {x y z : A}
(p : x == y) (q : y == z) (b : B x)
→ transport B (p ∙' q) b == transport B q (transport B p b) | transp-∙' _ idp _ = idp
{- Naturality of transport -} | function | transp-∙' | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-naturality : ∀ {i j k} {A : Type i} {B : A → Type j} {C : A → Type k}
(u : {a : A} → B a → C a)
{a₀ a₁ : A} (p : a₀ == a₁)
→ u ∘ transport B p == transport C p ∘ u | transp-naturality f idp = idp | function | transp-naturality | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"a₁",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-idp : ∀ {i j} {A : Type i} {B : Type j}
(f : A → B) {x y : A} (p : x == y)
→ transport (λ a → f a == f a) p idp == idp | transp-idp f idp = idp | function | transp-idp | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ap-∘-cst-coh : ∀ {i} {j} {k} {A : Type i} {B : Type j} {C : Type k}
(g : B → C) (b : B)
{x y : A} (p : x == y)
→ ∘-ap g (λ _ → b) p ◃∙
ap-cst (g b) p ◃∎
=ₛ
ap (ap g) (ap-cst b p) ◃∎ | ap-∘-cst-coh g b p@idp = =ₛ-in idp
{- Naturality of homotopies -} | function | ap-∘-cst-coh | core.lib | core/lib/PathFunctor.agda | [
"lib.Base",
"lib.PathGroupoid"
] | [
"Type",
"ap",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-idf-out : ∀ {i} {A B : Type i} (p : A == B) {u : A} {v : B}
→ u == v [ (λ X → X) ↓ p ]
→ coe p u == v | ↓-idf-out idp = idf _ | function | ↓-idf-out | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"coe",
"idf",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-idf-in : ∀ {i} {A B : Type i} (p : A == B) {u : A} {v : B}
→ coe p u == v
→ u == v [ (λ X → X) ↓ p ] | ↓-idf-in idp = idf _
-- Dependent paths over [ap f p] | function | ↓-idf-in | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"coe",
"idf",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-cst-in2-ap : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k}
{a a' : A} {b b' : B} {c c' : C}
(f : C → a == a') (g : C → b == b') (r : c == c')
→ ↓-cst-in2 {q = ap f r} (ap g r)
==
↓-ap-in (λ p → b == b' [ (λ _ → B) ↓ p ])
f
(apd (λ c → ↓-cst-in {p = f c} (g c)) r) | ↓-cst-in2-ap {c = c} {c' = .c} f g idp = ↓-cst-in2-idp (f c) (g c)
-- Dependent paths over [ap2 f p q] | function | ↓-cst-in2-ap | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"ap",
"apd",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
apd↓ : ∀ {i j k} {A : Type i} {B : A → Type j} {C : (a : A) → B a → Type k}
(f : {a : A} (b : B a) → C a b) {x y : A} {p : x == y}
{u : B x} {v : B y} (q : u == v [ B ↓ p ])
→ f u == f v [ (λ xy → C (fst xy) (snd xy)) ↓ pair= p q ] | apd↓ f {p = idp} idp = idp | function | apd↓ | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"fst",
"idp",
"pair=",
"snd"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-apd-out : ∀ {i j k} {A : Type i} {B : A → Type j} (C : (a : A) → B a → Type k)
{f : Π A B} {x y : A} {p : x == y}
{q : f x == f y [ B ↓ p ]} (r : apd f p == q)
{u : C x (f x)} {v : C y (f y)}
→ u == v [ uncurry C ↓ pair= p q ]
→ u == v [ (λ z → C z (f z)) ↓ p ] | ↓-apd-out C {p = idp} idp idp = idp | function | ↓-apd-out | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"apd",
"idp",
"pair=",
"uncurry"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
to-transp-weird : ∀ {i j} {A : Type i} {B : A → Type j}
{u v : A} {d : B u} {d' d'' : B v} {p : u == v}
(q : d == d' [ B ↓ p ]) (r : transport B p d == d'')
→ (from-transp B p r ∙'ᵈ (! r ∙ to-transp q)) == q | to-transp-weird {p = idp} idp idp = idp
-- Something not really clear yet | function | to-transp-weird | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-↓ : ∀ {i j} {A : Type i} (P : A → Type j) {a₁ a₂ : A}
(p : a₁ == a₂) (y : P a₂) → transport P (! p) y == y [ P ↓ p ] | transp-↓ _ idp _ = idp | function | transp-↓ | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"a₁",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
transp-ap-↓ : ∀ {i j k} {A : Type i} {B : Type j} (P : B → Type k) (h : A → B)
{a₁ a₂ : A} (p : a₁ == a₂) (y : P (h a₂))
→ transport P (! (ap h p)) y == y [ P ∘ h ↓ p ] | transp-ap-↓ _ _ idp _ = idp | function | transp-ap-↓ | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"ap",
"a₁",
"idp",
"transport"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
apd↓=apd : ∀ {i j} {A : Type i} {B : A → Type j} (f : (a : A) → B a) {x y : A}
(p : x == y) → (apd f p == ↓-ap-out _ _ p (apd↓ {A = Unit} f {p = idp} p)) | apd↓=apd f idp = idp
-- Paths in the fibrations [fst] and [snd] | function | apd↓=apd | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"Unit",
"apd",
"apd↓",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-ap-out= : ∀ {i j k} {A : Type i} {B : Type j} (C : (b : B) → Type k)
(f : A → B) {x y : A} (p : x == y)
{q : f x == f y} (r : ap f p == q)
{u : C (f x)} {v : C (f y)}
→ u == v [ C ↓ q ]
→ u == v [ (λ z → C (f z)) ↓ p ] | ↓-ap-out= C f idp idp idp = idp
-- No idea what that is | function | ↓-ap-out= | core.lib | core/lib/PathOver.agda | [
"lib.Base",
"lib.PathFunctor",
"lib.PathGroupoid",
"lib.Equivalence"
] | [
"Type",
"ap",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Rel : ∀ (A : Type i) j → Type (lmax i (lsucc j)) | Rel A j = A → A → Type j | function | Rel | core.lib | core/lib/Relation.agda | [
"lib.Base"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
empty-rel : ∀ {A : Type i} → Rel A lzero | empty-rel _ _ = Empty | function | empty-rel | core.lib | core/lib/Relation.agda | [
"lib.Base"
] | [
"Empty",
"Rel",
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-equiv : ∀ {i} {A B : Type i} → A == B → A ≃ B | coe-equiv p = (coe p , record { g = coe! p ; f-g = coe!-inv-r p ; g-f = coe!-inv-l p ; adj = coe-inv-adj p })
{- We postulate the univalence axiom as three separate axioms because it’s more
natural this way. But it doesn’t change anything in practice. -} | function | coe-equiv | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe",
"coe!",
"coe!-inv-l",
"coe!-inv-r",
"coe-inv-adj"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ua : ∀ {i} {A B : Type i} → (A ≃ B) → A == B | postulate | ua | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
coe-equiv-β : ∀ {i} {A B : Type i} (e : A ≃ B) → coe-equiv (ua e) == e | postulate | coe-equiv-β | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-equiv",
"ua"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
ua-η : ∀ {i} {A B : Type i} (p : A == B) → ua (coe-equiv p) == p | postulate | ua-η | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-equiv",
"ua"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
ua-equiv : ∀ {i} {A B : Type i} → (A ≃ B) ≃ (A == B) | ua-equiv = equiv ua coe-equiv ua-η coe-equiv-β
{- Reductions for coercions along a path constructed with the univalence axiom -} | function | ua-equiv | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-equiv",
"coe-equiv-β",
"ua",
"ua-η"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe-β : ∀ {i} {A B : Type i} (e : A ≃ B) (a : A)
→ coe (ua e) a == –> e a | coe-β e a = ap (λ e → –> e a) (coe-equiv-β e) | function | coe-β | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"ap",
"coe",
"coe-equiv-β",
"ua"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
coe!-β : ∀ {i} {A B : Type i} (e : A ≃ B) (b : B)
→ coe! (ua e) b == <– e b | coe!-β e a = ap (λ e → <– e a) (coe-equiv-β e)
{- Paths over a path in a universe in the identity fibration reduces -} | function | coe!-β | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"ap",
"coe!",
"coe-equiv-β",
"ua"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-idf-ua-out : ∀ {i} {A B : Type i} (e : A ≃ B) {u : A} {v : B}
→ u == v [ (λ x → x) ↓ (ua e) ]
→ –> e u == v | ↓-idf-ua-out e p = ! (coe-β e _) ∙ ↓-idf-out (ua e) p | function | ↓-idf-ua-out | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-β",
"ua",
"↓-idf-out"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
↓-idf-ua-in : ∀ {i} {A B : Type i} (e : A ≃ B) {u : A} {v : B}
→ –> e u == v
→ u == v [ (λ x → x) ↓ (ua e) ] | ↓-idf-ua-in e p = ↓-idf-in (ua e) (coe-β e _ ∙ p)
{- Induction along equivalences
If [P] is a predicate over all equivalences in a universe [Type i] and [d] is a
proof of [P] over all [ide A], then we get a section of [P]
-} | function | ↓-idf-ua-in | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-β",
"ua",
"↓-idf-in"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
equiv-induction : ∀ {i j} (P : {A B : Type i} (f : A ≃ B) → Type j)
(d : (A : Type i) → P (ide A)) {A B : Type i} (f : A ≃ B)
→ P f | equiv-induction {i} {j} P d f =
transport P (coe-equiv-β f)
(aux P d (ua f)) where
aux : ∀ {j} (P : {A : Type i} {B : Type i} (f : A ≃ B) → Type j)
(d : (A : Type i) → P (ide A)) {A B : Type i} (p : A == B)
→ P (coe-equiv p)
aux P d idp = d _
{- Univalence for pointed types -} | function | equiv-induction | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Type",
"coe-equiv",
"coe-equiv-β",
"ide",
"idp",
"transport",
"ua"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
⊙ua : ∀ {i} {X Y : Ptd i} → X ⊙≃ Y → X == Y | ⊙ua ((f , p) , ie) = ptd= (ua (f , ie)) (↓-idf-ua-in (f , ie) p) | function | ⊙ua | core.lib | core/lib/Univalence.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.PathFunctor",
"lib.Equivalence",
"lib.PathOver"
] | [
"Ptd",
"ptd=",
"ua",
"↓-idf-ua-in"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
Cube {i} {A : Type i} {a₀₀₀ : A} :
{a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
(sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀) -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁ == a₁₁₁}
(sq₋₋₁ :... | data | Cube | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Square",
"Type",
"idc",
"ids"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | ||
fill-cube-left-unique : ∀ {i} {A : Type i} {a₀₀₀ : A}
{a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
{sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀} -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁ ... | fill-cube-left-unique idc = idp | function | fill-cube-left-unique | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Cube",
"Square",
"Type",
"fst",
"idc",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
fill-cube-right-unique : ∀ {i} {A : Type i} {a₀₀₀ : A}
{a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
{sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀} -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁... | fill-cube-right-unique idc = idp
{- Paths as degenerate cubes -} | function | fill-cube-right-unique | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Cube",
"Square",
"Type",
"fst",
"idc",
"idp"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
ap-cube : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
{a₀₀₀ a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
{sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀} -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ ... | ap-cube f idc = idc | function | ap-cube | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Cube",
"Square",
"Type",
"ap-square",
"idc"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
natural-cube : ∀ {i j} {A : Type i} {B : Type j}
{f₀₀ f₀₁ f₁₀ f₁₁ : A → B}
{p₀₋ : (a : A) → f₀₀ a == f₀₁ a} {p₋₀ : (a : A) → f₀₀ a == f₁₀ a}
{p₋₁ : (a : A) → f₀₁ a == f₁₁ a} {p₁₋ : (a : A) → f₁₀ a == f₁₁ a}
(sq : ∀ a → Square (p₀₋ a) (p₋₀ a) (p₋₁ a) (p₁₋ a))
{x y : A} (q : x == y)
→ Cube (sq x) (sq y)
... | natural-cube sq idp = x-degen-cube idp | function | natural-cube | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Cube",
"Square",
"Type",
"idp",
"sq"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 | |
cube-rotate-x→z : ∀ {i} {A : Type i}
{a₀₀₀ a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
{sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀} -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁ == a₁₁₁}
{... | cube-rotate-x→z idc = idc | function | cube-rotate-x→z | core.lib.cubical | core/lib/cubical/Cube.agda | [
"lib.Base",
"lib.PathGroupoid",
"lib.cubical.Square"
] | [
"Cube",
"Square",
"Type",
"idc"
] | https://github.com/HoTT/HoTT-Agda | 1037d82edcf29b620677a311dcfd4fc2ade2faa6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.