https://github.com/groupoid/dan

🧊 Сімпліціальна теорія типів
https://github.com/groupoid/dan
Last synced: 10 months ago
JSON representation
🧊 Сімпліціальна теорія типів
Host: GitHub
URL: https://github.com/groupoid/dan
Owner: groupoid
Created: 2025-02-22T13:46:11.000Z (11 months ago)
Default Branch: main
Last Pushed: 2025-02-22T13:53:47.000Z (11 months ago)
Last Synced: 2025-02-22T14:36:50.026Z (11 months ago)
Language: OCaml
Homepage: http://dan.groupoid.space/
Size: 0 Bytes
Stars: 0
Watchers: 1
Forks: 0
Open Issues: 0
Metadata Files:
- Readme: README.md
Awesome Lists containing this project

README

          Dan Kan: Simplicial HoTT

========================

Groupoid Infinity Simplicial HoTT Computer Algebra System is a pure algebraїc implementation

with explicit syntaxt for fastest type checking. It supports following extensions: `Chain`,

`Cochain`, `Simplex`, `Simplicial`, `Category`, `Monoid`, `Group`, `Ring`.

Simplicial HoTT is a Rezk/GAP replacement incorporated into CCHM/CHM/HTS Agda-like Anders/Dan

with Kan, Rezk and Segal simplicial modes for computable ∞-categories.



## Abstract

We present a domain-specific language (DSL), the extension to Cubical Homotopy Type Theory (CCHM) for simplicial structures,

designed as a fast type checker with a focus on algebraic purity. Built on the Cohen-Coquand-Huber-Mörtberg (CCHM)

framework, our DSL employs a Lean/Anders-like sequent syntax `П (context) ⊢ k (v₀, ..., vₖ | f₀, ..., fₗ | ... )` to define 

k-dimensional `0, ..., n, ∞` simplices via explicit contexts, vertex lists, and face relations, eschewing geometric coherence terms

in favor of compositional constraints (e.g., `f = g ∘ h`). The semantics, formalized as inference rules in a Martin-Löf

Type Theory MLTT-like setting, include Formation, Introduction, Elimination, Composition, Computational, and

Uniqueness rules, ensuring a lightweight, deterministic computational model with linear-time type checking (O(k + m + n),

where k is vertices, m is faces, and n is relations). Inspired by opetopic purity, our system avoids cubical

path-filling (e.g., `PathP`), aligning with syntactic approaches to higher structures while retaining CCHM’s

type-theoretic foundation. Compared to opetopic sequent calculi and the Rzk prover, our DSL balances algebraic

simplicity with practical efficiency, targeting simplicial constructions over general ∞-categories,

and achieves a fast, pure checker suitable for formal proofs and combinatorial reasoning.

## Setup

```

$ ocamlopt -o dan src/simplicity.ml && ./dan

```

## Syntax

Incorporating into CCHM/CHM/HTS Anders/Dan core.

### Definition

New sequent contruction:

```

def  :  := П (context), conditions ⊢  (elements | constraints)

```

Instances:

```

def chain : Chain := П (context), conditions ⊢ n (C₀, C₁, ..., Cₙ | ∂₀, ∂₁, ..., ∂ₙ₋₁)

def simplicial : Simplicial := П (context), conditions ⊢ n (s₀, s₁, ..., sₙ | facemaps, degeneracies)

def group : Group := П (context), conditions ⊢ n (generators | relations)

def cat : Category := П (context), conditions ⊢ n (objects | morphisms | coherence)

```

### BNF

```

 ::=  |  

 ::= "def"  ":"  ":=" 

 ::= "Simplex" | "Simplicial" | "Chain" | "Cochain"

                          | "Category"  | "Group" | "Monoid" | "Ring" | "Field"

 ::= "П" "("  ")" "⊢"  "("  "|"  ")"

 ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

 ::= "¹" | "²" | "³" | "⁴" | "⁵" | "⁶" | "⁷" | "⁸" | "⁹"

 ::=  |   | "∞"

 ::=  |  "," 

 ::=  ":"                % Single declaration, e.g., a : Simplex

               | "("  ":"  ")"  % Grouped declaration, e.g., (a b c : Simplex)

               |  "="  "<"                % Map, e.g., ∂₁ = C₂ < C₃

               |  "="                         % Equality, e.g., x = 2

               |  "="  "∘"                % Monoid composition, e.g., ac = ab ∘ bc

               |  "="  "+"                % Ring addition, e.g., x + y = s

               |  "="  "⋅"                % Ring multiplication, e.g., x ⋅ y = p

               |  "="  "/"                % Field division, e.g., x / y = d

 ::=  |                   % e.g., a b c

 ::=  | ε

 ::=  |  "," 

 ::=  | ε

 ::=  |  "," 

 ::=  "="                         % Equality, e.g., a = 2

               |  "∘"  "="                 % Monoid composition, e.g., a ∘ a = e

               |  "+"  "="                 % Ring addition, e.g., x + y = s

               |  "⋅"  "="                 % Ring multiplication, e.g., x ⋅ y = p

               |  "/"  "="                 % Field division, e.g., x / y = d

               |  "<"                       % Map, e.g., ∂₁ < C₂

 ::=                                         % e.g., a

      |  "∘"                                  % e.g., a ∘ b

      |  "+"                                  % e.g., x + y

      |  "⋅"                                  % e.g., x ⋅ y

      |  "/"                                  % e.g., x / y

      |  "^-1"                                   % e.g., a^-1

      |  "^"                        % e.g., a³

      | "e"                                         % identity

      |                                     % e.g., 2

      |                                     % e.g., [[1,2],[3,4]]

 ::=  |               % e.g., 123

 ::= "["  "]"                     % e.g., [[1,2],[3,4]]

 ::=  |  "," 

 ::= "["  "]"                     % e.g., [1,2]

 ::=  |  ","   % e.g., 1,2

```

Meaning of `` Across Types:

* Simplex: Dimension of the simplex—e.g., n=2 for a triangle (2-simplex).

* Group: Number of generators—e.g., n=1 for Z/3Z (one generator a).

* Simplicial: Maximum dimension of the simplicial set—e.g., n=1 for S1 (up to 1-simplices).

* Chain: Length of the chain (number of levels minus 1)—e.g., n=2 for a triangle chain (0, 1, 2 levels).

* Category: Number of objects—e.g., n=2 for a path category (two objects x,y).

* Monoid: Number of generators—e.g., n=2 for N (zero and successor).

## Semantics

### Chain

* Formation. Γ ⊢ Chain : Set

* Intro. Γ ⊢ n (S `|` R) : Chain  if  Γ = s₀₁, …, sₙₘₙ : Simplex, r₁, …, rₚ ∧ S₀, S₁, …, Sₙ = (s₀₁, …, s₀ₘ₀), …, (sₙ₁, …, sₙₘₙ) ∧ ∀ rⱼ = tⱼ = tⱼ', Γ ⊢ rⱼ : tⱼ = tⱼ' ∧ ∀ ∂ᵢⱼ < sₖₗ, Γ ⊢ ∂ᵢⱼ : sₖₗ → sₖ₋₁,ₘ

* Elim Face. Γ ⊢ ∂ᵢⱼ s : Simplex  if  Γ ⊢ n (S `|` R) : Chain ∧ r = ∂ᵢⱼ < s ∧ r ∈ R ∧ s ∈ S

* Comp Face. ∂ᵢⱼ (n (S `|` R)) → s'  if  r = ∂ᵢⱼ < s' ∧ r ∈ R ∧ s' ∈ S

* Uniq Face. Γ ⊢ ∂ᵢⱼ s ≡ ∂ᵢⱼ s'  if  Γ ⊢ n (S `|` R) : Chain ∧ n (S' `|` R') : Chain ∧ s ∈ S ∧ s' ∈ S' ∧ ∀ r = ∂ᵢⱼ < s ∈ R ∧ r' = ∂ᵢⱼ < s' ∈ R'

### Cochain

* Formation. Γ ⊢ Cochain : Set

* Intro. Γ ⊢ n (S `|` R) : Cochain  if  Γ = s₀₁, …, sₙₘₙ : Simplex, r₁, …, rₚ ∧ S₀, S₁, …, Sₙ = (s₀₁, …, s₀ₘ₀), …, (sₙ₁, …, sₙₘₙ) ∧ ∀ rⱼ = tⱼ = tⱼ', Γ ⊢ rⱼ : tⱼ = tⱼ' ∧ ∀ σᵢⱼ < sₖₗ, Γ ⊢ σᵢⱼ : sₖₗ → sₖ₊₁,ₘ

* Elim Degeneracy. Γ ⊢ σᵢⱼ s : Simplex  if  Γ ⊢ n (S `|` R) : Cochain ∧ r = σᵢⱼ < s ∧ r ∈ R ∧ s ∈ S

* Comp Degeneracy. σᵢⱼ (n (S `|` R)) → s'  if  r = σᵢⱼ < s' ∧ r ∈ R ∧ s' ∈ S

* Uniq Degeneracy. Γ ⊢ σᵢⱼ s ≡ σᵢⱼ s'  if  Γ ⊢ n (S `|` R) : Cochain ∧ n (S' `|` R') : Cochain ∧ s ∈ S ∧ s' ∈ S' ∧ ∀ r = σᵢⱼ < s ∈ R ∧ r' = σᵢⱼ < s' ∈ R'

### Category

* Formation. Γ ⊢ Category : Set

* Intro. Γ ⊢ n (O `|` M `|` R) : Category  if  Γ = o₁, …, oₙ, m₁, …, mₖ : Simplex, r₁, …, rₚ ∧ O = (o₁, …, oₙ) ∧ M = (m₁, …, mₙ) ∧ ∀ rⱼ = tⱼ = tⱼ', Γ ⊢ rⱼ : tⱼ = tⱼ' ∧ ∀ tⱼ = mₐ ∘ mᵦ, mₐ, mᵦ ∈ Γ

* Elim Comp. Γ ⊢ c : Simplex  if  Γ ⊢ n (O `|` M `|` R) : Category ∧ r = c = m₁ ∘ m₂ ∧ r ∈ R ∧ m₁, m₂ ∈ Γ

* Comp Comp. (m₁ ∘ m₂) (n (O `|` M `|` R)) → c  if  r = c = m₁ ∘ m₂ ∧ r ∈ R ∧ m₁, m₂ ∈ Γ

* Uniq Comp. Γ ⊢ c ≡ c'  if  Γ ⊢ n (O `|` M `|` R) : Category ∧ n (O' `|` M' `|` R') : Category ∧ r = c = m₁ ∘ m₂ ∈ R ∧ r' = c' = m₁' ∘ m₂' ∈ R' ∧ m₁, m₂ ∈ Γ ∧ m₁', m₂' ∈ Γ'

### Monoid

* Formation. Γ ⊢ Monoid : Set

* Intro. Γ ⊢ n (M `|` R) : Monoid  if  Γ = m₁, …, mₙ : Simplex, r₁, …, rₚ ∧ M = (m₁, …, mₙ) ∧ ∀ rⱼ = tⱼ = tⱼ', Γ ⊢ rⱼ : tⱼ = tⱼ' ∧ ∀ tⱼ = mₐ ∘ mᵦ, mₐ, mᵦ ∈ M

* Elim Comp. Γ ⊢ c : Simplex  if  Γ ⊢ n (M `|` R) : Monoid ∧ r = c = m₁ ∘ m₂ ∧ r ∈ R ∧ m₁, m₂ ∈ M

* Comp Comp. (m₁ ∘ m₂) (n (M `|` R)) → c  if  r = c = m₁ ∘ m₂ ∧ r ∈ R ∧ m₁, m₂ ∈ M

* Uniq Comp. Γ ⊢ c ≡ c'  if  Γ ⊢ n (M `|` R) : Monoid ∧ n (M' `|` R') : Monoid ∧ r = c = m₁ ∘ m₂ ∈ R ∧ r' = c' = m₁' ∘ m₂' ∈ R' ∧ m₁, m₂ ∈ M ∧ m₁', m₂' ∈ M'

   

### Simplex

* Formation. Γ ⊢ Simplex : Set

* Intro. Γ ⊢ n (S `|` R) : Simplex  if  Γ = s₀, …, sₙ : Simplex, r₁, …, rₚ ∧ `|`S`|` = n + 1 ∧ ∀ rⱼ = tⱼ = tⱼ', Γ ⊢ rⱼ : tⱼ = tⱼ' ∧ ∀ ∂ᵢ < sₖ, Γ ⊢ ∂ᵢ : sₖ → sₖ₋₁ ∧ ∀ σᵢ < sₖ, Γ ⊢ σᵢ : sₖ → sₖ₊₁

* Elim Face. Γ ⊢ ∂ᵢ s : Simplex  if  Γ ⊢ n (S `|` R) : Simplex ∧ r = ∂ᵢ < s ∧ r ∈ R ∧ s ∈ S

* Elim Degeneracy. Γ ⊢ σᵢ s : Simplex  if  Γ ⊢ n (S `|` R) : Simplex ∧ r = σᵢ < s ∧ r ∈ R ∧ s ∈ S

* Comp Face. ∂ᵢ (n (S `|` R)) → s'  if  r = ∂ᵢ < s' ∧ r ∈ R ∧ s' ∈ S

* Comp Degeneracy. σᵢ (n (S `|` R)) → s'  if  r = σᵢ < s' ∧ r ∈ R ∧ s' ∈ S

* Uniq Face. Γ ⊢ ∂ᵢ s ≡ ∂ᵢ s'  if  Γ ⊢ n (S `|` R) : Simplex ∧ n (S' `|` R') : Simplex ∧ s ∈ S ∧ s' ∈ S' ∧ ∀ r = ∂ᵢ < s ∈ R ∧ r' = ∂ᵢ < s' ∈ R'

* Uniq Degeneracy. Γ ⊢ σᵢ s ≡ σᵢ s'  if  Γ ⊢ n (S `|` R) : Simplex ∧ n (S' `|` R') : Simplex ∧ s ∈ S ∧ s' ∈ S' ∧ ∀ r = σᵢ < s ∈ R ∧ r' = σᵢ < s' ∈ R'

### Simplicial

#### Simplicial Modes

* Γ ⊢ Δₙ : Type (Simplex)

* Γ ⊢ Δₙᵏᵃⁿ : Type

* Γ ⊢ Δₙʳᵉᶻᵏ : Type

* Γ ⊢ Δₙˢᵉᵍᵃˡ : Type

#### Formation

The simplicial type is declared as a set within the context Γ without any premises.

```

Γ ⊢ Δ : Type

```

#### Introduction

A simplicial set of rank n with elements S and constraints R is formed from context Γ if simplices, equalities, face maps, and degeneracy maps are properly defined.

```

Γ ⊢ n (S | R) : Simplicial if

Γ = s₀₁, …, sₙₘₙ : Simplex, r₁, …, rₚ ∧

    S₀, S₁, …, Sₙ = (s₀₁, …, s₀ₘ₀), …, (sₙ₁, …, sₙₘₙ) ∧

    rⱼ = tⱼ = tⱼ',

Γ ⊢ rⱼ : tⱼ = tⱼ' ∧

    ∂ᵢⱼ < sₖₗ,

Γ ⊢ ∂ᵢⱼ : sₖₗ → sₖ₋₁,ₘ ∧

    σᵢⱼ < sₖₗ,

Γ ⊢ σᵢⱼ : sₖₗ → sₖ₊₁,ₘ

```

#### Elim Face

The face map ∂ᵢⱼ extracts a simplex from s in a simplicial set if the constraint r defines the face relation.

```

Γ ⊢ ∂ᵢⱼ s : Simplex if

Γ ⊢ n (S | R) : Simplicial ∧

    r = ∂ᵢⱼ < s ∧

    r ∈ R ∧

    s ∈ S                                  

```

#### Elim Composition

The composition s₁ ∘ s₂ yields a simplex c in a simplicial set if the constraint r defines it and s1 and s2 are composable.

```

Γ ⊢ c : Simplex if

Γ ⊢ n (S | R) : Simplicial ∧

    r = c = s₁ ∘ s₂ ∧

    r ∈ R ∧ s₁, s₂ ∈ S ∧

Γ ⊢ ∂ᵢᵢ₋₁ s₁ = ∂ᵢ₀ s₂

```

#### Elim Degeneracy

The degeneracy map σᵢⱼ lifts a simplex s to a higher simplex in a simplicial set if the constraint r defines the degeneracy relation.

```

Γ ⊢ σᵢⱼ s : Simplex if

Γ ⊢ n (S | R) : Simplicial ∧

    r = σᵢⱼ < s,

    r ∈ R,

    s ∈ S

```

#### Face Computation

The face map ∂ᵢⱼ applied to a simplicial set reduces to the simplex s′ specified by the constraint r in R.

```

∂ᵢⱼ (n (S | R)) → s' if

    r = ∂ᵢⱼ < s' ∧

    r ∈ R ∧

    s' ∈ S

```

#### Composition Computation.

The composition s₁ ∘ s₂ applied to a simplicial set reduces to the simplex c specified by the constraint r in R, given s1 and s2 are composable.

```

(s₁ ∘ s₂) (n (S | R)) → c if

    r = c = s₁ ∘ s₂ ∧

    r ∈ R ∧

    s₁, s₂ ∈ S ∧

Γ ⊢ ∂ᵢᵢ₋₁ s₁ = ∂ᵢ₀ s₂

```

#### Degeneracy Computation.

The degeneracy map σᵢⱼ applied to a simplicial set reduces to the simplex s′ specified by the constraint r in R.

```

σᵢⱼ (n (S | R)) → s' if

    r = σᵢⱼ < s' ∧ 

    r ∈ R ∧ 

    s' ∈ S

```

#### Face Uniqueness

Two face maps ∂ᵢⱼ s and ∂ᵢⱼ s′ are equal if they are defined by constraints r and r′ across two simplicial sets with matching elements.

```

Γ ⊢ ∂ᵢⱼ s ≡ ∂ᵢⱼ s'  if  

Γ ⊢ n (S | R) : Simplicial ∧ 

    n (S' | R') : Simplicial ∧ 

    s ∈ S ∧ s' ∈ S' ∧ 

    r = ∂ᵢⱼ < s ∈ R ∧ 

    r' = ∂ᵢⱼ < s' ∈ R'

```

#### Uniqueness of Composition.

Two composed simplices c and c′ are equal if their constraints r and r′ define compositions of matching pairs s₁, s₂ and s₁′, s₂′ across two simplicial sets with composability conditions.

```

Γ ⊢ c ≡ c' if

Γ ⊢ n (S | R) : Simplicial ∧

    n (S' | R') : Simplicial ∧ 

    r = c = s₁ ∘ s₂ ∈ R ∧

    r' = c' = s₁' ∘ s₂' ∈ R' ∧

    s₁, s₂ ∈ S ∧ 

    s₁', s₂' ∈ S' ∧ 

Γ ⊢ ∂ᵢᵢ₋₁ s₁ = ∂ᵢ₀ s₂ ∧ 

Γ ⊢ ∂ᵢᵢ₋₁ s₁' = ∂ᵢ₀ s₂'

```

#### Uniqueness of Degeneracy.

Two degeneracy maps σᵢⱼ s and σᵢⱼ s′ are equal if they are defined by constraints r and r′ across two simplicial sets with matching elements.

```

Γ ⊢ σᵢⱼ s ≡ σᵢⱼ s' if

Γ ⊢ n (S | R) : Simplicial ∧

    n (S' | R') : Simplicial ∧

    s ∈ S ∧

    s' ∈ S' ∧

    r = σᵢⱼ < s ∈ R ∧

    r' = σᵢⱼ < s' ∈ R'

```

## Examples

### N-Monoid

```

def nat_monoid : Monoid

 := П (z s : Simplex),

      s ∘ z = s, z ∘ s = s

    ⊢ 2 (z s | s ∘ z = s, z ∘ s = s)

```

O(5).

### Category with Group (Path Category with Z/2Z)

```

def path_z2_category : Category

 := П (x y : Simplex),

      (f g h : Simplex),

      (z2 : Group(П (e a : Simplex), a² = e ⊢ 1 (a | a² = e))),

      f ∘ g = h

    ⊢ 2 (x y | f g h | f ∘ g = h)

```

O(8)—5 context + 2 nested group + 1 constraint—linear with nesting.

### Triangle Chain

```

def triangle_chain : Chain

 := П (v₀ v₁ v₂ e₀₁ e₀₂ e₁₂ t : Simplex),

      ∂₁₀ = e₀₁, ∂₁₁ = e₀₂, ∂₁₂ = e₁₂, ∂₂ < e₀₁ e₀₂ e₁₂

    ⊢ 2 (v₀ v₁ v₂, e₀₁ e₀₂ e₁₂, t | ∂₁₀ ∂₁₁ ∂₁₂, ∂₂)

```

O(11).

### Simplicial Circle

```

def circle : Simplicial

 := П (v e : Simplex),

       ∂₁₀ = v, ∂₁₁ = v, s₀ < v

     ⊢ 1 (v, e | ∂₁₀ ∂₁₁, s₀)

```

O(5).

### Z/3Z

```

def z3 : Group

 := П (e a : Simplex),

      a³ = e

    ⊢ 1 (a | a³ = e)

```

O(4).

### Triangle

```

def triangle : Simplex := П (a b c : Simplex),

         (ab bc ca : Simplex), ac = ab ∘ bc

         ⊢ 2 (a b c | ab bc ca)

```

O(7).

### Singular Cone

```

def singular_cone : Simplex

 := П (p q r s : Simplex),

      (qrs prs pqs : Simplex), pqr = pqs ∘ qrs

    ⊢ 3 (p q r s | qrs prs pqs pqr)

```

Context: p, q, r, s: Simplex (vertices), qrs, prs, pqs : Simplex (faces), pqr = pqs ∘ qrs.

Simplex: Dimension 3, 4 faces.

### Möbius Piece

```

def Möbius : Simplex

 := П (a b c : Simplex),

      (bc ac : Simplex), ab = bc ∘ ac

    ⊢ 2 (a b c | bc ac ab)

```

Context: a, b, c : Simplex (vertices), bc, ac : Simplex (faces), ab = bc ∘ ac (relation).

Simplex: Dimension 2, 3 faces.

### Degenerate Tetrahedron

```

def degen_tetra : Simplex

 := П (p q r s : Simplex, q = r),

      (qrs prs pqs : Simplex), pqr = pqs ∘ qrs

    ⊢ 3 (p q r s | qrs prs pqs pqr)

```

Context: p, q, r, s : Simplex, q = r (degeneracy), qrs, prs, pqs : Simplex, pqr = pqs ∘ qrs.

Simplex: Dimension 3, 4 faces—degeneracy implies a collapsed edge.

Non-Triviality: q = r flattens the structure algebraically, testing composition under equality.

### Twisted Annulus

```

def twisted_annulus : Simplex

 := П (a b c d : Simplex),

      (bc ac bd : Simplex), ab = bc ∘ ac, cd = ac ∘ bd

    ⊢ 2 (a b c | bc ac ab), 2 (b c d | bc bd cd)

```

Context:

* Vertices:  a, b, c, d.

* Faces: bc, ac, bd.

* Relations: ab = bc ∘ ac,  cd = ac ∘ bd  (twist via composition).

  

Simplices:

* (a b c `|` bc, ac, ab ): First triangle.

* (b c d `|` bc, bd, cd ): Second triangle, sharing bc.

  

Checking:

* Vertices: a, b, c, d ∈ Γ — O(4).

* Faces: bc, ac, ab (O(3)), bc, bd, cd (O(3)) — total O(6).

* Relations: ab = bc ∘ ac (O(1)), cd = ac ∘ bd (O(1)) — O(2).

* Total: O(12) — linear, fast.

### Degenerate Triangle (Collapsed Edge)

```

def degen_triangle : Simplex

 := П (a b c : Simplex, b = c),

      (bc ac : Simplex), ab = bc ∘ ac

    ⊢ 2 (a b c | bc ac ab)

```

Context: 

* Vertices: a, b, c, with b = c.

* Faces: bc, ac.

* Relation: ab = bc ∘ ac.

Simplex:

* (a b c `|` bc, ac, ab ) — 3 faces, despite degeneracy.

Checking:

* Vertices: a, b, c ∈ Γ, b = c — O(3).

* Faces: bc, ac, ab ∈ Γ — O(3).

* Relation: ab = bc ∘ ac — O(1).

* Total: O(7)—efficient, handles degeneracy cleanly.

### Singular Prism (Degenerate Face)

```

def singular_prism : Simplex

 := П (p q r s t : Simplex),

      (qrs prs pqt : Simplex, qrs = qrs), pqr = pqt ∘ qrs

    ⊢ 3 (p q r s | qrs prs pqt pqr)

```

Context: 

* Vertices: p, q, r, s, t.

* Faces: qrs, prs, pqt.

* Relations: qrs = qrs (degenerate identity), pqr = pqt ∘ qrs.

Simplex: 

* (p q r s `|` qrs, prs, pqt, pqr ) — 4 faces, one degenerate.

Checking:

* Vertices: p, q, r, s ∈ Γ (t unused, valid) — O(4).

* Faces: qrs, prs, pqt, pqr ∈ Γ — O(4).

* Relations: qrs = qrs (O(1)), pqr = pqt ∘ qrs (O(1)) — O(2).

* Total: O(10) — linear, fast despite degeneracy.

### S¹ as ∞-Groupoid

```

def s1_infty : Simplicial

 := П (v e : Simplex),

      ∂₁₀ = v, ∂₁₁ = v, s₀ < v,

      ∂₂₀ = e ∘ e, s₁₀ < ∂₂₀

    ⊢ ∞ (v, e, ∂₂₀ | ∂₁₀ ∂₁₁, s₀, ∂₂₀, s₁₀)

```

AST:

```

(* Infinite S¹ ∞-groupoid *)

let s1_infty = {

  name = "s1_infty";

  typ = Simplicial;

  context = [

    Decl (["v"; "e"], Simplex);  (* Base point and loop *)

    Equality ("∂₁₀", Id "v", Id "∂₁₀");

    Equality ("∂₁₁", Id "v", Id "∂₁₁");

    Equality ("s₀", Id "e", Id "s₀");

    Equality ("∂₂₀", Comp (Id "e", Id "e"), Id "∂₂₀");  (* 2-cell: e ∘ e *)

    Equality ("s₁₀", Id "∂₂₀", Id "s₁₀")  (* Degeneracy for 2-cell *)

  ];

  rank = Infinite;  (* Unbounded dimensions *)

  elements = ["v"; "e"; "∂₂₀"];  (* Finite truncation: 0-, 1-, 2-cells *)

  constraints = [

    Eq (Id "∂₁₀", Id "v");

    Eq (Id "∂₁₁", Id "v");

    Map ("s₀", ["v"]);

    Eq (Id "∂₂₀", Comp (Id "e", Id "e"));

    Map ("s₁₀", ["∂₂₀"])

  ]

}

```

### ∞-Category with cube fillers

```

def cube_infty : Category := П (a b c : Simplex),

       (f g h : Simplex), cube2 = g ∘ f, cube2 : Simplex,

       cube3 = cube2 ∘ f, cube3 : Simplex

       ⊢ ∞ (a b c | cube2 cube3)

```

### Matrix Ring Spectrum

```

def matrix_ring_spectrum : Ring

 := П (a b s p : Simplex),

      a + b = s, a ⋅ b = p,

      a = [[1,2],[3,4]], b = [[0,1],[1,0]], s = [[1,3],[4,4]], p = [[2,1],[4,3]]

    ⊢ 4 (a b s p | a + b = s, a ⋅ b = p, a = [[1,2],[3,4]], b = [[0,1],[1,0]],

                   s = [[1,3],[4,4]], p = [[2,1],[4,3]])

```

### HZ spectrum

```

def hz_spectrum : Ring

 := П (x y p : Simplex),

      x ⋅ y = p,

      x = 2, y = 3, p = 6

    ⊢ 3 (x y p | x ⋅ y = p, x = 2, y = 3, p = 6)

```

### Poly Ring spectrum

```

def poly_ring_zx : Ring

 := П (f g s p : Simplex),

      f + g = s, f ⋅ g = p,

      f = x + 1, g = 2 ⋅ x, s = 3 ⋅ x + 1, p = 2 ⋅ x ⋅ x + 2 ⋅ x

    ⊢ 4 (f g s p | f + g = s, f ⋅ g = p, f = x + 1, g = 2 ⋅ x,

                   s = 3 ⋅ x + 1, p = 2 ⋅ x ⋅ x + 2 ⋅ x)

```

### GF(2⁴) Finite Field

```

def gf16 : Field

 := П (x y s p d : Simplex),

      x + y = s, x ⋅ y = p, x / y = d,

      x = Z(2^4), y = Z(2^4)^2,

      s = Z(2^4) + Z(2^4)^2,

      p = Z(2^4)^3, d = Z(2^4)^14

    ⊢ 5 (x y s p d | x + y = s, x ⋅ y = p, x / y = d,

                     x = Z(2^4), y = Z(2^4)^2,

                     s = Z(2^4) + Z(2^4)^2,

                     p = Z(2^4)^3,

                     d = Z(2^4)^14)

```

### GF(7) Prime Field

```

def gf7 : Field

 := П (x y s p d : Simplex),

      x + y = s, x ⋅ y = p, x / y = d,

      x = 2, y = 3, s = 5, p = 6, d = 3

    ⊢ 5 (x y s p d | x + y = s, x ⋅ y = p,

         x / y = d, x = 2, y = 3,

         s = 5, p = 6, d = 3)

```

## Bibliography

* Daniel Kan. Abstract Homotopy I. 1955.

* Daniel Kan. Abstract Homotopy II. 1956.

* Daniel Kan. On c.s.s. Complexes. 1957.

* Daniel Kan. A Combinatorial Definition of Homotopy Groups. 1958.

* Daniel Kan, W. G. Dwyer. Adjoint functors. 1958.

* Daniel Kan, W. G. Dwyer.  Simplicial Localizations of Categories. 1980.

* Graeme Segal. Classifying spaces and spectral sequences. 1968.

* Graeme Segal. Categories and cohomology theories. 1974.

* Graeme Segal, R. Bott. Loop groups and their classifying spaces. 1988.

* Charles Rezk. A model for the homotopy theory of homotopy theory. 2001.

* Charles Rezk. A cartesian presentation of weak n-categories". 2010.

* Charles Rezk, S. Schwede, B. Shipley. Simplicial structures on model categories and functors. 2001.

* Charles Rezk, J. Bergner. Comparison of models for (∞,n)-categories. 2013.

## Conclusion

Dan Kan Simplicity HoTT, hosted at groupoid/dan, is a lightweight, pure type checker

built on Cubical Homotopy Type Theory (CCHM), named in tribute to Daniel Kan for

his foundational work on simplicial sets. With a unified syntax — 

`П (context) ⊢ n (elements | constraints)` — Dan supports a rich type

system `Simplex`, `Group`, `Simplicial`, `Chain`, `Category`, `Monoid`, now extended with 

∞-categories featuring cube fillers.
ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/groupoid/dan

Awesome Lists containing this project

README
