Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. β’ 103 items β’ Updated β’ 3
statement stringlengths 5 595 | proof stringlengths 0 691 | type stringclasses 2
values | symbolic_name stringlengths 1 27 | library stringclasses 1
value | filename stringclasses 30
values | imports listlengths 0 2 | deps listlengths 0 8 | docstring stringclasses 32
values | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
+ : nat β nat β nat | :=
elim [
| zero => n => n
| suc {_ => ih} => n => suc {ih n}
] | def | + | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
+0L : (x : nat) β path nat {+ 0 x} x | :=
x _ => x | def | +0L | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
+SL : (x y : nat) β path nat {+ {suc x} y} {suc {+ x y}} | :=
x y _ => suc {+ x y} | def | +SL | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
+0R : (x : nat) β path nat {+ x 0} x | :=
elim [
| zero => +0L 0
| suc {x => ih} =>
equation nat begin
+ {suc x} 0 =[ +SL x 0 ]
suc {+ x 0} =[ i => suc {ih i} ]
suc x
end
] | def | +0R | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"+0L",
"+SL",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
+SR : (x y : nat) β path nat {+ x {suc y}} {suc {+ x y}} | :=
elim [
| zero =>
y =>
equation nat begin
+ 0 {suc y} =[ +0L {suc y} ]
suc y =[ i => suc {symm nat {+0L y} i} ]
suc {+ 0 y}
end
| suc {x => ih} =>
y =>
equation nat begin
+ {suc x} {suc y} =[ +SL x {suc y} ]
suc {+ x {suc y}} =[ i => suc {ih y i} ]
suc {su... | def | +SR | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"+0L",
"+SL",
"path",
"symm"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
+A : (x y z : nat) β path nat {+ {+ x y} z} {+ x {+ y z}} | :=
elim [
| zero =>
y z =>
equation nat begin
+ {+ 0 y} z =[ i => + {+0L y i} z ]
+ y z =[ symm nat {+0L {+ y z}} ]
+ 0 {+ y z}
end
| suc {x => ih} =>
y z =>
equation nat begin
+ {+ {suc x} y} z =[ i => + {+SL x y i} z ]
+ {suc {+ x y}} z =[ +SL {+ x y} z ]
... | def | +A | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"+0L",
"+SL",
"path",
"symm"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
natβ·set : set # [tp := nat] | axiom | natβ·set | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"set"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | ||
foo (p : path nat {+ 0 0} 0) : unfold + in path {path nat {+ 0 0} 0} p {_ => 0} | :=
unfold + has-hlevel in
natβ·set 0 0 p {_ => 0} | def | foo | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"has-hlevel",
"natβ·set",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
two : nat | := + 1 1 | def | two | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
test : path nat two 2 | :=
unfold two + in
i => 2 | def | test | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"path",
"two"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
test2 : path-p {i => path nat two {test i}} {_ => two} test | :=
i j =>
unfold two + in
2 | def | test2 | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [
"+",
"path",
"path-p",
"test",
"two"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
abs-test : nat | :=
suc {abstract abs-test::foo β 41} | def | abs-test | test | test/abstract.cooltt | [
"hlevel",
"prelude"
] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
monoid : type | :=
sig
def t : type
def op : t β t β t
def emp : t
def opL : (u : t) β path t {op emp u} u
def opR : (u : t) β path t {op u emp} u
def opA : (u v w : t) β path t {op {op u v} w} {op u {op v w}}
end | def | monoid | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
commutative-monoid : type | :=
sig
include monoid
def opC : (u v : t) β path t {op u v} {op v u}
end | def | commutative-monoid | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"monoid",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
multiplicative-monoid : type | :=
sig
include monoid
renaming [op β mul; emp β one; opL β mulL; opR β mulR; opA β mulA]
end | def | multiplicative-monoid | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"monoid"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
additive-monoid : type | :=
sig
include monoid
renaming [op β add; emp β zer; opL β addL; opR β addR; opA β addA]
end | def | additive-monoid | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"monoid"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
abelian-group : type | :=
sig
include additive-monoid
def neg : t β t
def addC : (u v : t) β path t {add u v} {add v u}
def add-neg : (u : t) β path t {add {neg u} u} zer
end | def | abelian-group | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"additive-monoid",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
ring : type | :=
sig
def t : type
include abelian-group # [ t ::= t ]
include multiplicative-monoid # [ t ::= t ]
end | def | ring | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"abelian-group",
"multiplicative-monoid"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
monoid/nat : monoid # [t := nat] | :=
struct
def op := +
def emp := 0
def opL := +-left-unit
def opR := +-right-unit
def opA := +-assoc
end | def | monoid/nat | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"+",
"+-assoc",
"+-left-unit",
"+-right-unit",
"monoid"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
monoid/nat/+ : monoid # [t := nat, op := +] | :=
struct
def emp := 0
def opL := +-left-unit
def opR := +-right-unit
def opA := +-assoc
end | def | monoid/nat/+ | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"+",
"+-assoc",
"+-left-unit",
"+-right-unit",
"monoid"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
additive-monoid/nat : additive-monoid # [ t := nat ] | :=
struct
include monoid/nat
renaming [op β add; emp β zer; opL β addL; opR β addR; opA β addA]
end | def | additive-monoid/nat | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"additive-monoid",
"monoid/nat"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
monoid/unit : monoid # [t := unit] | :=
struct
def op := _ _ => 0
def emp := 0
def opL := _ _ => 0
def opR := _ _ => 0
def opA := _ _ _ _ => 0
end | def | monoid/unit | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"monoid",
"unit"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
abelian-group/unit : abelian-group # [t := unit] | :=
struct
include monoid/unit
renaming [op β add; emp β zer; opL β addL; opR β addR; opA β addA]
def neg := _ => 0
def addC := _ _ _ => 0
def add-neg := _ _ => 0
end | def | abelian-group/unit | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"abelian-group",
"monoid/unit",
"unit"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
ring/unit : ring # [t := unit] | :=
struct
include abelian-group/unit
include monoid/unit
renaming [op β mul; emp β one; opL β mulL; opR β mulR; opA β mulA]
end | def | ring/unit | test | test/algebra.cooltt | [
"nat",
"prelude"
] | [
"abelian-group/unit",
"monoid/unit",
"ring",
"unit"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
empty : type | := path nat 0 1 | def | empty | test | test/base-types.cooltt | [
"prelude"
] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
abort (P : empty -> type) (e : empty) : P e | :=
unfold empty in
let myelim : nat -> type := elim [ zero => unit | suc _ => P e ] in
coe {i => myelim {e i}} 0 1 β | def | abort | test | test/base-types.cooltt | [
"prelude"
] | [
"empty",
"unit",
"β"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
sum (A B : type) : type | :=
let famβ·shifted : nat -> type := elim [ zero => B | suc _ => empty ] in
let fam : nat -> type := elim [ zero => A | suc n => famβ·shifted n ] in
(n : nat) * fam n | def | sum | test | test/base-types.cooltt | [
"prelude"
] | [
"empty"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
inl (A B : type) (x : A) : sum A B | :=
[ 0 , x ] | def | inl | test | test/base-types.cooltt | [
"prelude"
] | [
"sum"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
inr (A B : type) (y : B) : sum A B | :=
[ 1 , y ] | def | inr | test | test/base-types.cooltt | [
"prelude"
] | [
"sum"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
case (A B : type) (P : sum A B -> type)
(P/inl : (a : A) -> P {inl A B a})
(P/inr : (b : B) -> P {inr A B b})
(s : sum A B) : P s | :=
let fam/shifted : nat -> type := elim [ zero => B | suc _ => empty ] in
let curried/shifted : (n : nat) (e : fam/shifted n) -> unfold sum in P [ suc n , e ] :=
unfold inr in
elim [ zero => P/inr | suc n => e => abort {_ => P [ suc {suc n} , e ]} e ]
in
let fam : nat -> type := elim [ zero => A | suc ... | def | case | test | test/base-types.cooltt | [
"prelude"
] | [
"abort",
"empty",
"inl",
"inr",
"sum"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
reflβ‘reflΒ―ΒΉ (A : type) (x : A) : path {path A x x} {refl A x} {symm A {refl A x}} | :=
j i =>
unfold symm in
symm/filler A {refl A x} i j | def | reflβ‘reflΒ―ΒΉ | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"refl",
"symm",
"symm/filler"
] | Lemma 3.2.1 (inversion unit) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
reflβ‘reflβrefl (A : type) (x : A) : path {path A x x} {refl A x} {trans A {refl A x} {refl A x}} | :=
unfold trans in
trans/filler A {refl A x} {refl A x} | def | reflβ‘reflβrefl | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"refl",
"trans",
"trans/filler"
] | Lemma 3.2.2 (composition unit) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
pβ‘pβrefl (A : type) (p : π β A) : path {path A {p 0} {p 1}} p {trans A p {refl A {p 1}}} | :=
unfold trans in
trans/filler A p {refl A {p 1}} | def | pβ‘pβrefl | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"refl",
"trans",
"trans/filler"
] | Lemma 3.2.3 (right unit) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
reflβ‘pβpΒ―ΒΉ (A : type) (p : π β A) : path {path A {p 0} {p 0}} {refl A {p 0}} {trans A p {symm A p}} | :=
k i =>
unfold trans symm in
hcom 0 1 {j =>
[ j=0 β¨ i=0 => p i
| i=1 β¨ k=0 => symm/filler A p j i
| k=1 => trans/filler A p {symm A p} j i
]
} | def | reflβ‘pβpΒ―ΒΉ | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"refl",
"symm",
"symm/filler",
"trans",
"trans/filler"
] | Lemma 3.2.4 (right cancellation) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
square (A : type) : type | :=
sig
def top : ext i => A with []
def bot : ext i => A with []
def left : ext i => A with [i=0 => top 0 | i=1 => bot 0]
def right : ext i => A with [i=0 => top 1 | i=1 => bot 1]
def filler : ext i j => A with [i=0 => top j | i=1 => bot j | j=0 => left i | j=1 => right i]
end | def | square | test | test/bruno.cooltt | [
"prelude"
] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
swap (A : type) (sq : square A)
: square A #
[top := sq.bot,
bot := sq.top,
left := symm A {sq.left},
right := symm A {sq.right}] | :=
unfold symm in
struct
def filler :=
i k => hcom 0 1 {j =>
[ i=0 => sq.filler j k
| i=1 β¨ j=0 => sq.top k
| k=0 => symm/filler A {sq.left} i j
| k=1 => symm/filler A {sq.right} i j
]
}
end | def | swap | test | test/bruno.cooltt | [
"prelude"
] | [
"square",
"symm",
"symm/filler"
] | Lemma 3.2.5 (square swap) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
symm-invol (A : type) (p : π β A) : path {path A {p 0} {p 1}} p {symm A {symm A p}} | :=
let a : A := p 0 in
let b : A := p 1 in
let true-at-refl : path {path A b b} {refl A b} {symm A {symm A {refl A b}}} :=
trans {path A b b} {reflβ‘reflΒ―ΒΉ A b} {i => symm A {reflβ‘reflΒ―ΒΉ A b i}}
in
let back : square A :=
unfold trans in
struct
def top := symm A p
def bot := trans A {sym... | def | symm-invol | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"refl",
"reflβ‘reflΒ―ΒΉ",
"square",
"swap",
"symm",
"trans",
"trans/filler"
] | Lemma 3.2.6 (inversability) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
opβ (A : type) (p : π β A) : path-p {i => path A {p 0} {symm A p i}} p {refl A {p 0}} | :=
k i =>
unfold trans in
hcom 0 1 {j =>
[ i=0 => p 0
| i=1 => symm A p k
| j=0 => trans/filler A p {symm A p} k i
| k=0 => p i
| k=1 => symm {path A {p 0} {p 0}} {reflβ‘pβpΒ―ΒΉ A p} j i
]
} | def | opβ | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"path-p",
"refl",
"reflβ‘pβpΒ―ΒΉ",
"symm",
"trans",
"trans/filler"
] | Lemma 3.2.7(i) (opposite identification) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
reflβ‘pΒ―ΒΉβp (A : type) (p : π β A) : path {path A {p 1} {p 1}} {refl A {p 1}} {trans A {symm A p} p} | :=
k i =>
unfold trans in
hcom 0 1 {j =>
[ i=0 => p 1
| i=1 => symm {path A {p 0} {p 1}} {symm-invol A p} k j
| j=0 => symm A p i
| k=0 => opβ A {symm A p} j i
| k=1 => trans/filler A {symm A p} p j i
]
} | def | reflβ‘pΒ―ΒΉβp | test | test/bruno.cooltt | [
"prelude"
] | [
"opβ",
"path",
"refl",
"symm",
"symm-invol",
"trans",
"trans/filler"
] | Lemma 3.2.8 (left cancellation) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
opβ (A : type) (p : π β A) : path-p {i => path A {p 1} {p i}} {symm A p} {refl A {p 1}} | :=
k i =>
unfold trans in
hcom 0 1 {j =>
[ i=0 => p 1
| i=1 => p k
| j=0 => trans/filler A {symm A p} p k i
| k=0 => symm A p i
| k=1 => symm {path A {p 1} {p 1}} {reflβ‘pΒ―ΒΉβp A p} j i
]
} | def | opβ | test | test/bruno.cooltt | [
"prelude"
] | [
"path",
"path-p",
"refl",
"reflβ‘pΒ―ΒΉβp",
"symm",
"trans",
"trans/filler"
] | Lemma 3.2.7(ii) (opposite identification) the paper mentions that this can be solved in a "similar argument" to 3.2.7(i), but for the truly symmetric proof (nearly identical to opβ) you need 3.2.8. so this is kind of nonlinear and might not be how the author intended? | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
pβ‘reflβp (A : type) (p : π β A) : path {path A {p 0} {p 1}} p {trans A {refl A {p 0}} p} | :=
k i =>
unfold trans in
hcom 0 1 {j =>
[ i=0 => p 0
| i=1 => opβ A p j k
| j=0 => opβ A p k i
| k=0 => p i
| k=1 => trans/filler A {refl A {p 0}} p j i
]
} | def | pβ‘reflβp | test | test/bruno.cooltt | [
"prelude"
] | [
"opβ",
"opβ",
"path",
"refl",
"trans",
"trans/filler"
] | Lemma 3.2.9 (left unit) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
bottom-id (A : type) (Ξ± : π β π β A) (Ξ² : (i j : π) β sub A {β j β¨ i=0} {Ξ± i j}) : path {path A {Ξ± 1 0} {Ξ² 1 1}} {Ξ± 1} {Ξ² 1} | :=
k i =>
hcom 0 1 {j =>
[ β i β¨ j=0 β¨ k=0 => Ξ± j i
| k=1 => Ξ² j i
]
} | def | bottom-id | test | test/bruno.cooltt | [
"prelude"
] | [
"path"
] | Lemma 3.2.10 (bottom identification) we represent squares as just their filler here, not the struct | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
assoc
(A : type)
(p : π β A)
(q : (i : π) β sub A {i=0} {p 1})
(r : (i : π) β sub A {i=0} {q 1})
: path {path A {p 0} {r 1}} {trans A {trans A p q} r} {trans A p {trans A q r}} | :=
unfold trans in
let Ξ± : square A :=
struct
def top := p
def bot := trans A {trans A p q} r
def left := refl A {p 0}
def right := trans A q r
def filler :=
k i => hcom 0 1 {j =>
[ i=0 => p 0
| i=1 => trans/filler A q r j k
| j=0 => trans/fill... | def | assoc | test | test/bruno.cooltt | [
"prelude"
] | [
"bottom-id",
"path",
"refl",
"square",
"trans",
"trans/filler"
] | Lemma 3.2.11 (associativity) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
hsymm (A : π β type) (p : (i : π) β A i) : path-p {symm type A} {p 1} {p 0} | :=
i =>
unfold symm in
com {symm/filler type A i} 0 1 {β i} {j =>
[ i=0 => p j
| i=1 β¨ j=0 => p 0
]
} | def | hsymm | test | test/bruno.cooltt | [
"prelude"
] | [
"path-p",
"symm",
"symm/filler"
] | Lemma 3.3.1 (heterogeneous inversion) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
htrans
(A : π β type)
(B : (i : π) β sub type {i=0} {A 1})
(p : (i : π) β A i) (q : (i : π) β sub {B i} {i=0} {p 1})
: path-p {trans type A B} {p 0} {q 1} | :=
i =>
unfold trans in
com {j => trans/filler type A B j i} 0 1 {β i} {j =>
[ j=0 β¨ i=0 => p i
| i=1 => q j
]
} | def | htrans | test | test/bruno.cooltt | [
"prelude"
] | [
"path-p",
"trans",
"trans/filler"
] | Lemma 3.3.2 (heterogeneous composition) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
is-refl (A : type) (p : π β A) : path-p {i => path A {p 0} {p i}} {refl A {p 0}} p | :=
k i =>
hcom 0 1 {j =>
[ i=0 => p 0
| i=1 => opβ A p k j
| j=0 => pβ‘pβrefl A p k i
| k=0 => opβ A p j i
| k=1 => symm {path A {p 0} {p 1}} {pβ‘pβrefl A p} j i
]
} | def | is-refl | test | test/bruno.cooltt | [
"prelude"
] | [
"opβ",
"opβ",
"path",
"path-p",
"pβ‘pβrefl",
"refl",
"symm"
] | Theorem 4.1.1 (path induction) | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
J (A : type) (a : A) (P : (x : A) β {path A a x} β type) (u : P a {refl A a}) (p : (i : π) β sub A {i=0} a) : P {p 1} p | :=
coe {i => P {p i} {is-refl A p i}} 0 1 u | def | J | test | test/bruno.cooltt | [
"prelude"
] | [
"is-refl",
"path",
"refl"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
path (A : type) (a b : A) : type | :=
ext i => A with [i=0 => a | i=1 => b] | def | path | test | test/circle.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
Ξ©1s1 : type | :=
path circle base base | def | Ξ©1s1 | test | test/circle.cooltt | [] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
loopn : nat -> Ξ©1s1 | :=
elim [
| zero => _ => base
| suc {n => loopn} =>
i =>
hcom circle 0 1 {β i} {k =>
[ k=0 => loopn i
| i=0 => base
| i=1 => loop k
]
}
] | def | loopn | test | test/circle.cooltt | [] | [
"Ξ©1s1"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
_ (A : π β type) (src : π) (trg : π) (x : A src) : sub {A trg} {src=trg} x | :=
coe A src trg x | def | _ | test | test/coercion.cooltt | [
"prelude"
] | [] | This is the Cartesian coercion operator. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
coe/fwd (A : π β type) (x : A 0) : A 1 | :=
coe A 0 1 x | def | coe/fwd | test | test/coercion.cooltt | [
"prelude"
] | [] | A special case of coercion is that if we have a path of types A0 = A1, we can cast/coerce (x : A0) to an element of A1. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
coe/bwd (A : π β type) (x : A 1) : A 0 | :=
coe A 1 0 x | def | coe/bwd | test | test/coercion.cooltt | [
"prelude"
] | [] | ...and conversely. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
transport/fwd (A : type) (B : A β type) (p : π β A) (x : B {p 0}) : B {p 1} | :=
coe/fwd {i => B {p i}} x | def | transport/fwd | test | test/coercion.cooltt | [
"prelude"
] | [
"coe/fwd"
] | By combining coe with ap (the fact that functions respect paths), we can show that if we have a path (a0 = a1 : A) and an A-indexed family B of types, then we can transport (x : B a0) to an element of (B a1). | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
_ (A : π β type) (x : A 0) : path-p A x {coe/fwd A x} | :=
i => coe A 0 i x | def | _ | test | test/coercion.cooltt | [
"prelude"
] | [
"coe/fwd",
"path-p"
] | If we coerce (x : A0) to an interval variable, we get a dependent path from x to the coercion of x. That's because of the side condition that coe is the identity function when src=trg. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
heterogenize (A : π β type) (p : π β A 0) : path-p A {p 0} {coe/fwd A {p 1}} | :=
i => coe A 0 i {p i} | def | heterogenize | test | test/coercion.cooltt | [
"prelude"
] | [
"coe/fwd",
"path-p"
] | Here's another use of coercing to an interval variable. If we have a homogeneous path in A0, we can turn it into a heterogeneous path in A from its left endpoint to the coercion of its right endpoint. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
homogenize (A : π β type) (p : (i : π) β A i) : path {A 1} {coe/fwd A {p 0}} {p 1} | :=
i => coe A i 1 {p i} | def | homogenize | test | test/coercion.cooltt | [
"prelude"
] | [
"coe/fwd",
"path"
] | Dually, we can coerce *from* an interval variable to turn a heterogeneous path into a homogeneous one. | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
mycoe/fun
(A : (i : π) β type) (B : (i: π) β type)
(coe/A : (r : π) (x : A r) (i : π) β sub {A i} {i=r} x)
(coe/B : (r : π) (x : B r) (i : π) β sub {B i} {i=r} x)
(r : π) (f : (_ : A r) β B r) (i : π)
: sub {(_ : A i) β B i} {i=r} f | :=
x =>
coe/B r {f {coe/A i x r}} i | def | mycoe/fun | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
mycom/fun
(A B : π β type)
(com/A : (r : π) (Ο : π½) (p : (i : π) β [i=r β¨ Ο] β A i) (i : π) β sub {A i} {i=r β¨ Ο} {p i})
(com/B : (r : π) (Ο : π½) (p : (i : π) β [i=r β¨ Ο] β B i) (i : π) β sub {B i} {i=r β¨ Ο} {p i})
(r : π) (Ο : π½) (p : (i : π) β [i=r β¨ Ο] β A i β B i) (i : π)
: sub {(_ : A i) β B... | :=
x =>
com/B r Ο {j => p j {com/A i β₯ {_ => x} j}} i | def | mycom/fun | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
coe/intro (A : π β type) (r r' : π) (x : A r) : sub {A r'} {r=r'} x | :=
coe A r r' x | def | coe/intro | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
coe/pi
(A : π β type) (B : (i : π) β A i β type)
(r r' : π)
(f : (x : A r) β B r x)
: sub {(x : A r') β B r' x} β€ {x => coe {i => B i {coe A r' i x}} r r' {f {coe A r' r x}}} | :=
coe {i => (x : A i) β B i x} r r' f | def | coe/pi | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
coe/sigma
(A : π β type) (B : (i : π) β A i β type)
(r r' : π)
(p : (x : A r) Γ B r x)
: sub {(x : A r') Γ B r' x} β€ [coe A r r' {fst p}, coe {i => B i {coe A r i {fst p}}} r r' {snd p}] | :=
coe {i => (x : A i) Γ B i x} r r' p | def | coe/sigma | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
pathd (A : π β type) (a : A 0) (b : A 1) : type | :=
ext i => A i with [i=0 => a | i=1 => b] | def | pathd | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
coe/pathd
(A : π -> π -> type)
(r r' : π)
(a : (i : π) -> A i 0)
(b : (i : π) -> A i 1)
(m : pathd {A r} {a r} {b r})
: sub {pathd {A r'} {a r'} {b r'}} β€ {j =>
com {i => A i j} r r' {β j} {i =>
[j=0 => a i | j=1 => b i | i=r => m j]
}
} | :=
coe {i => pathd {A i} {a i} {b i}} r r' m | def | coe/pathd | test | test/com.cooltt | [] | [
"pathd"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
hcom/intro
(A : type) (r r' : π) (Ο : π½)
(p : (i : π) β [i=r β¨ Ο] β A)
: sub A {r=r' β¨ Ο} {p r'} | :=
hcom A r r' Ο p | def | hcom/intro | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
hcom/fun
(A B : type) (r r' : π) (Ο : π½)
(p : (i : π) β [i=r β¨ Ο] β A β B)
: sub {A β B} β€ {x => hcom B r r' Ο {j => p j x}} | :=
hcom {A β B} r r' Ο p | def | hcom/fun | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
com/intro
(A : π β type) (r r' : π) (Ο : π½)
(p : (i : π) β [i=r β¨ Ο] β A i)
: sub {A r'} {r=r' β¨ Ο} {p r'} | :=
com A r r' Ο p | def | com/intro | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
com/decomposition
(A : π β type) (r r' : π) (Ο : π½)
(p : (i : π) β [i=r β¨ Ο] β A i)
: sub {A r'} β€ {hcom {A r'} r r' Ο {j => coe A j r' {p j}}} | :=
com A r r' Ο p | def | com/decomposition | test | test/com.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
fully-patched (fam : sig [x : nat] -> type) (fib : fam {struct [x := 0]}) : fam # [x := 0] | :=
fib | def | fully-patched | test | test/cool-total-space.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
not-fully-patched (fam : sig [x : nat] -> type) (fib : fam {struct [x := 0]}) : fam | :=
struct [x := 0, fib := fib] | def | not-fully-patched | test | test/cool-total-space.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
no-insert-fib (fam : sig [x : nat] -> type) (total : fam) : nat | :=
total.x | def | no-insert-fib | test | test/cool-total-space.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
insert-fib-plain (fam : sig [x : nat] -> type) (total : fam) : fam {struct [x := total.x]} | :=
total | def | insert-fib-plain | test | test/cool-total-space.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
insert-fib-pi : sig [fam : sig [x : nat] -> type, test : fam -> nat] | :=
struct
def fam := _ => nat -> nat
def test := total => total 0
end | def | insert-fib-pi | test | test/cool-total-space.cooltt | [] | [
"test"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
insert-fib-sg : sig [fam : sig [x : nat] -> type, test : fam -> nat] | :=
struct
def fam := _ => nat * nat
def test := total => fst total
end | def | insert-fib-sg | test | test/cool-total-space.cooltt | [] | [
"test"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
no-insert-fib-record : sig [fam : sig [x : nat] -> type, test : fam -> nat] | :=
struct
def fam := _ => sig [y : nat]
def test := total => total.fib.y
end | def | no-insert-fib-record | test | test/cool-total-space.cooltt | [] | [
"test"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
test-hole (fam : sig [x : nat] -> type) : fam # [x := 0] | := ? | def | test-hole | test | test/cool-total-space.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
boundary-test : (i : π) β [β i] β nat | :=
i =>
[ i=1 => 5
| i=0 => 19
] | def | boundary-test | test | test/elab.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
reflexivity : (A : type) (a : A) (i : π) β A | :=
A a _ => a | def | reflexivity | test | test/elab.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
pi-code-test : type | := (x : nat) β nat | def | pi-code-test | test | test/elab.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
foo : pi-code-test | :=
x => x | def | foo | test | test/elab.cooltt | [] | [
"pi-code-test"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
simple-let :
(A : type) (a : A) -> A | :=
A a =>
let b : A := a in
b | def | simple-let | test | test/elab.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
hole-in-type :
(x y z : nat)
β ?tyhole | :=
y z => ?tmhole | def | hole-in-type | test | test/elab.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
bar : (x : nat) β (y : nat) Γ path nat x y | :=
x =>
[x, ?hole1] | def | bar | test | test/elab.cooltt | [] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
equational/trans (a : type) (x y z : a) (p : path a x y) (q : path a y z) : path a x z | :=
equation a begin
x =[ p ]
y =[ q ]
z
end | def | equational/trans | test | test/equation.cooltt | [
"prelude"
] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
equational/refl/nat : path nat 4 4 | :=
equation nat begin
4 =[]
4
end | def | equational/refl/nat | test | test/equation.cooltt | [
"prelude"
] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
refl2 (A : type) (p : (i : π) β A) : sub {path {path A {p 0} {p 1}} p p} β€ {_ => p} | :=
_ => p | def | refl2 | test | test/evan.cooltt | [
"prelude"
] | [
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
test (A : type) (p : (i : π) β A) : (j : π) β path A {p 0} {p 1} | :=
j => refl2 A p j | def | test | test | test/evan.cooltt | [
"prelude"
] | [
"path",
"refl2"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
a1 : nat | := 0 | def | a1 | test | test/export.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
a2 : nat | := 10 | def | a2 | test | test/export.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
a3 : nat | := 20 | def | a3 | test | test/export.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
special-j (A : type) (x : A) (B : (Ο : π½) β {(i : π) β sub A {i=0 β¨ Ο} x} β type)
(d : B β€ {_ => x})
(Ο : π½) (p : (i : π) β sub A {i=0 β¨ Ο} x)
: sub {B Ο p} Ο d | :=
let filler : π β π β A :=
j i =>
hcom A 0 i {β j β¨ Ο} {i =>
[ i=0 β¨ j=0 β¨ Ο => p 0
| j=1 => p i
]
}
in
com {j => B {Ο β¨ j=0} {filler j}} 0 1 {Ο} {j => d} | def | special-j | test | test/groupoid-laws.cooltt | [
"prelude"
] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
trans (A : type) (p : (i : π) β A)
: (Ο : π½) (q : (i : π) β sub A {i=0 β¨ Ο} {p 1})
β sub {path A {p 0} {q 1}} Ο p | :=
special-j A {p 1} {_ q => path A {p 0} {q 1}} p | def | trans | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"path",
"special-j"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
assoc (A : type)
(p : (i : π) β A)
(Ο : π½) (q : (i : π) β sub A {i=0 β¨ Ο} {p 1})
: (Ο : π½) (r : (i : π) β sub A {i=0 β¨ Ο} {q 1})
β sub {path {path A {p 0} {r 1}} {trans A {trans A p Ο q} Ο r} {trans A p {Ο β§ Ο} {trans A q Ο r}}}
Ο {_ => trans A p Ο q} | :=
special-j A {q 1}
{Ο r => path {path A {p 0} {r 1}} {trans A {trans A p Ο q} Ο r} {trans A p {Ο β§ Ο} {trans A q Ο r}}}
{_ => trans A p Ο q} | def | assoc | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"path",
"special-j",
"trans"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
pentagonType (A : type)
(p : (i : π) β A)
(Ο : π½) (q : (i : π) β sub A {i=0 β¨ Ο} {p 1})
(Ο : π½) (r : (i : π) β sub A {i=0 β¨ Ο} {q 1})
(Ο : π½) (s : (i : π) β sub A {i=0 β¨ Ο} {r 1})
: type | :=
path
{path
{path A {p 0} {s 1}}
{trans A {trans A {trans A p Ο q} Ο r} Ο s}
{trans A p {Ο β§ Ο β§ Ο} {trans A q {Ο β§ Ο} {trans A r Ο s}}}}
{trans {path A {p 0} {s 1}}
{assoc A {trans A p Ο q} Ο r Ο s}
{Ο β§ Ο}
{assoc A p Ο q {Ο β§ Ο} {trans A r Ο s}}}
{trans {path A ... | def | pentagonType | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"assoc",
"path",
"trans"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
pentagon (A : type)
(p : (i : π) β A)
(Ο : π½) (q : (i : π) β sub A {i=0 β¨ Ο} {p 1})
(Ο : π½) (r : (i : π) β sub A {i=0 β¨ Ο} {q 1})
: (Ο : π½) (s : (i : π) β sub A {i=0 β¨ Ο} {r 1})
β pentagonType A p Ο q Ο r Ο s | :=
special-j A {r 1}
{pentagonType A p Ο q Ο r}
{special-j A {q 1}
{Ο r => pentagonType A p Ο q Ο r β€ {_ => r 1}}
{special-j A {p 1}
{Ο q => pentagonType A p Ο q β€ {_ => q 1} β€ {_ => q 1}}
{_ _ => p}
Ο q}
Ο r} | def | pentagon | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"pentagonType",
"special-j"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
trans' (A : type) (p : (i : π) β A) (q : (i : π) β sub A {i=0} {p 1})
: path A {p 0} {q 1} | :=
trans A p β₯ q | def | trans' | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"path",
"trans"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
assoc' (A : type)
(p : (i : π) β A)
(q : (i : π) β sub A {i=0} {p 1})
(r : (i : π) β sub A {i=0} {q 1})
: path {path A {p 0} {r 1}} {trans' A {trans' A p q} r} {trans' A p {trans' A q r}} | :=
assoc A p β₯ q β₯ r | def | assoc' | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"assoc",
"path",
"trans'"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
pentagon' (A : type)
(p : (i : π) β A)
(q : (i : π) β sub A {i=0} {p 1})
(r : (i : π) β sub A {i=0} {q 1})
(s : (i : π) β sub A {i=0} {r 1})
: path
{path
{path A {p 0} {s 1}}
{trans' A {trans' A {trans' A p q} r} s}
{trans' A p {trans' A q {trans' A r s}}}}
{trans' {path A {p... | :=
pentagon A p β₯ q β₯ r β₯ s | def | pentagon' | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"assoc'",
"path",
"pentagon",
"trans'"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
test (A : type)
(p : (i : π) β A)
(q : (i : π) β sub A {i=0} {p 1})
(r : (i : π) β sub A {i=0} {q 1})
(s : (i : π) β sub A {i=0} {r 1})
: (j : π) β path A {p 0} {r 1} | :=
j => assoc A p β₯ q β₯ r j | def | test | test | test/groupoid-laws.cooltt | [
"prelude"
] | [
"assoc",
"path"
] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 | |
v-test (r : π) (A : type) : type | :=
V r A A
[ x => x
, x =>
[ [x, _ => x]
, p i =>
let aux := hfill A 1 {β i} {k => [ k=1 => x | i=1 => {snd p} k | i=0 => x ] } in
[aux 0, aux]
]
] | def | v-test | test | test/hcom-type.cooltt | [] | [] | https://github.com/RedPRL/cooltt | b39bf29900451cb43ae6fbd9af5aa33d59e18935 |
End of preview. Expand in Data Studio
cooltt
Declarations from cooltt, a cubical/computational type theory system.
Source
- Repository: https://github.com/RedPRL/cooltt
- Commit:
b39bf29900451cb43ae6fbd9af5aa33d59e18935 - Files: 32
- License: other
Schema
| Column | Type | Description |
|---|---|---|
| statement | string | Declaration signature/claim with the leading keyword removed (verbatim slice); the full declaration minus its proof |
| proof | string | Verbatim proof/body, empty if the declaration has none |
| type | string | Declaration keyword |
| symbolic_name | string | Declaration identifier |
| library | string | Sub-library |
| filename | string | Repository-relative source path |
| imports | list[string] | File-level Require/Import modules |
| deps | list[string] | Intra-corpus identifiers referenced |
| docstring | string | Preceding documentation comment, empty if absent |
| source_url | string | Upstream repository |
| commit | string | Upstream commit extracted |
Statistics
- Entries: 228
- With proof: 221 (96.9%)
- With docstring: 31 (13.6%)
- Libraries: 1
By type
| Type | Count |
|---|---|
| def | 221 |
| axiom | 7 |
Example
+0R : (x : nat) β path nat {+ x 0} x
:=
elim [
| zero => +0L 0
| suc {x => ih} =>
equation nat begin
+ {suc x} 0 =[ +SL x 0 ]
suc {+ x 0} =[ i => suc {ih i} ]
suc x
end
]
- type: def | symbolic_name:
+0R| test/abstract.cooltt
Use
Each declaration is split into a statement (signature/claim) and a proof (body) that are disjoint
and together form the complete declaration, for proof modeling, autoformalization, retrieval, and
dependency analysis via deps.
Citation
@misc{cooltt_dataset,
title = {cooltt},
author = {Norton, Charles},
year = {2026},
note = {Extracted from https://github.com/RedPRL/cooltt, commit b39bf2990045},
url = {https://huggingface.co/datasets/phanerozoic/cooltt}
}
- Downloads last month
- 24