statement stringlengths 2 515 | proof stringlengths 0 3.49k | type stringclasses 4
values | symbolic_name stringlengths 1 23 | library stringclasses 3
values | filename stringclasses 56
values | imports listlengths 0 0 | deps listlengths 0 7 | docstring stringclasses 1
value | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
Choice/compose/tt/ff :
(->
[a b c : nat]
[p0/t : ($ Choice b c)]
[p1/t : ($ Choice (succ a) b)]
(=
($ Choice (succ a) (succ c))
($ Choice/compose (succ a) (succ b) (succ c)
(tuple [head tt] [tail p0/t]) (tuple [head ff] [tail p1/t]))
(tuple [head ff] [tail ($ Choice/compose (succ a) b c... | by {
lam a b c p0/t p1/t =>
auto;
unfold Choice; reduce; assumption
}. | theorem | Choice/compose/tt/ff | example | example/semi-simplicial.prl | [] | [
"Choice",
"Choice/compose"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Choice/compose/ff :
(->
[a b c : nat]
[p0/t : ($ Choice (succ b) c)]
[p1 : ($ Choice (succ a) (succ b))]
(=
($ Choice (succ a) (succ c))
($ Choice/compose (succ a) (succ b) (succ c)
(tuple [head ff] [tail p0/t]) p1)
(tuple [head ff] [tail ($ Choice/compose (succ a) (succ b) c p0/t p1)])... | by {
lam a b c p0/t p1 =>
auto;
unfold Choice; reduce; assumption
}. | theorem | Choice/compose/ff | example | example/semi-simplicial.prl | [] | [
"Choice",
"Choice/compose"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Eq/inv :
(-> [a : (U 0)] [x y : a]
(= a x y) (= a y x)) | by {
lam a x y eq => assumption
}. | theorem | Eq/inv | example | example/semi-simplicial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Choice/compose/assoc :
(->
[a b c d : nat]
[p0 : ($ Choice c d)]
[p1 : ($ Choice b c)]
[p2 : ($ Choice a b)]
(=
($ Choice a d)
($ Choice/compose a b d ($ Choice/compose b c d p0 p1) p2)
($ Choice/compose a c d p0 ($ Choice/compose a b c p1 p2)))) | by {
lam a => elim a;
[ lam b c d p0 p1 p2 => unfold Choice/compose; auto ]; // a = 0
with a'/ind a' => lam b => elim b;
[ lam c d p0 p1 p2 => elim p2 ]; // b = 0
with b'/ind b' => lam c => elim c;
[ lam d p0 p1 => elim p1 ]; // c = 0
with c'/ind c' => lam d => elim d;
[ lam p0 => elim p0 ]; // d = 0
... | theorem | Choice/compose/assoc | example | example/semi-simplicial.prl | [] | [
"Choice",
"Choice/compose",
"Choice/compose/ff",
"Choice/compose/tt/ff",
"Choice/compose/tt/tt"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
MegaMutualDefs :
(-> nat
(record
[sst : (U 1)]
[folder : (-> sst nat (U 0))]
[pick : (-> [x : sst]
[n m : nat] ($ Choice n m)
($ folder x n)
($ folder x m))]
[pick-coh : (-> [x : sst] [n m o : nat]
[c1 : ($ Choice m o)]
[c2 : ($ Choice n m)]
... | by {
lam p => elim p;
[
{ sst = `record
, folder = lam x n => `record
, pick = lam x n m c f => `tuple
, pick-coh = lam x n m o c1 c2 f => `ax
};
, with p'/ind p' =>
let {sst=sst', folder=folder', pick=pick', pick-coh=pick-coh'}
= p'/ind;
{ sst = `(* [x : sst'] (-> ($ folder' x p... | theorem | MegaMutualDefs | example | example/semi-simplicial.prl | [] | [
"Choice",
"Choice/compose",
"Choice/compose/assoc",
"Eq/inv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
SemiSimplicial :
(-> nat (U 1)) | by {
lam n => `(! sst ($ MegaMutualDefs n))
}. | theorem | SemiSimplicial | example | example/semi-simplicial.prl | [] | [
"MegaMutualDefs"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Choice(#i:lvl) :
(->
[a b : (U #i)]
[r : (-> a b (U #i))]
[f : (-> [x : a] (* [y : b] ($ r x y)))]
(*
[f : (-> a b)]
(-> [x : a] ($ r x ($ f x))))) | by {
lam a b r f =>
{lam x => let {y,_} = f [`x]; `y,
lam x => let {_,z} = f [`x]; `z};
inversion; with _ aux0 => reduce at left in aux0; auto; assumption
}. | theorem | Choice | example | example/theorem-of-choice.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Not :
(-> bool bool) | by {
lam b =>
if b then `ff else `tt
}. | theorem | Not | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
NotNot :
(->
[b : bool]
(= bool ($ Not ($ Not b)) b)) | by {
lam b =>
// The next four lines can be replaced by auto.
unfold Not;
if b
then (reduce at left; refine bool/eq/tt)
else (reduce at left; refine bool/eq/ff)
}. | theorem | NotNot | example | example/tutorial.prl | [] | [
"Not"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RespectEquality :
(->
[family : (-> [b : bool] (U 0))]
[b : bool]
($ family b)
($ family ($ Not ($ Not b)))) | by {
lam family b pf =>
rewrite ($ NotNot b);
[ with b' => `($ family b')
, use pf
];
auto
}. | theorem | RespectEquality | example | example/tutorial.prl | [] | [
"Not",
"NotNot"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EqualityIrrelevant :
(=
(-> [b : bool] (= bool ($ Not ($ Not b)) b))
NotNot
(lam [b] ax)) | by {
auto
}. | theorem | EqualityIrrelevant | example | example/tutorial.prl | [] | [
"Not",
"NotNot"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathFunToPair :
(->
[ty : (U 0 kan)]
(path [_] (U 0 kan) (-> bool ty) (* ty ty))) | by {
lam ty => abs x =>
`(V x (-> bool ty) (* ty ty)
(tuple [proj1 ($ FunToPair ty)] [proj2 ($ FunToPairIsEquiv ty)]))
}. | theorem | PathFunToPair | example | example/tutorial.prl | [] | [
"FunToPair",
"FunToPairIsEquiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RespectPaths :
(->
[ty : (U 0 kan)]
(-> bool ty)
(* ty ty)) | by {
lam ty fun =>
`(coe 0~>1 [x] (@ ($ PathFunToPair ty) x) fun)
}. | theorem | RespectPaths | example | example/tutorial.prl | [] | [
"PathFunToPair"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
ComputeCoercion :
(=
(* bool bool)
($ RespectPaths bool (lam [b] b))
(tuple [proj1 tt] [proj2 ff])) | by {
auto
}. | theorem | ComputeCoercion | example | example/tutorial.prl | [] | [
"RespectPaths"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Refl :
(->
[ty : (U 0)]
[a : ty]
(path [_] ty a a)) | by {
lam ty a =>
abs _ => `a
}. | theorem | Refl | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
FunPath :
(->
[a b : (U 0)]
[f g : (-> a b)]
(path [_] (-> a b) f g)
[arg : a]
(path [_] b ($ f arg) ($ g arg))) | by {
lam a b f g p =>
lam arg => abs x =>
`($ (@ p x) arg)
}. | theorem | FunPath | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathInv :
(->
[ty : (U 0 kan)]
[a b : ty]
[p : (path [_] ty a b)]
(path [_] ty b a)) | by {
// a -- x
// ------- |
// | | y
// p | | a
// | |
// b .... a
lam ty a b p =>
abs x =>
`(hcom 0~>1 ty a [x=0 [y] (@ p y)] [x=1 [_] a])
}. | theorem | PathInv | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathConcat :
(->
[ty : (U 0 kan)]
[a b c : ty]
[p : (path [_] ty a b)]
[q : (path [_] ty b c)]
(path [_] ty a c)) | by {
// p -- x
// ------- |
// | | y
// a | | q
// | |
// a .... c
lam ty a b c p q =>
abs x =>
`(hcom 0~>1 ty (@ p x) [x=0 [_] a] [x=1 [y] (@ q y)])
}. | theorem | PathConcat | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
InvRefl :
(->
[ty : (U 0 kan)]
[a : ty]
(path
[_] (path [_] ty a a)
($ PathInv ty a a (abs [_] a))
(abs [_] a))) | by {
// See diagram!
lam ty a =>
abs x y =>
`(hcom 0~>1 ty a
[x=0 [z] (hcom 0~>z ty a [y=0 [_] a] [y=1 [_] a])]
[x=1 [_] a]
[y=0 [_] a]
[y=1 [_] a])
}. | theorem | InvRefl | example | example/tutorial.prl | [] | [
"PathInv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
J(#l:lvl) :
(->
[ty : (U #l kan)]
[a : ty]
[fam : (-> [x : ty] (path [_] ty a x) (U #l kan))]
[d : ($ fam a (abs [_] a))]
[x : ty]
[p : (path [_] ty a x)]
($ fam x p)) | by {
lam ty a fam d x p =>
`(coe 0~>1
[i] ($ fam
(hcom 0~>1 ty a [i=0 [_] a] [i=1 [j] (@ p j)])
(abs [j] (hcom 0~>j ty a [i=0 [_] a] [i=1 [j] (@ p j)]))) d)
}. | theorem | J | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
JInv :
(->
[ty : (U 0 kan)]
[a b : ty]
[p : (path [_] ty a b)]
(path [_] ty b a)) | by {
lam ty a b p =>
exact
($ (J #lvl{0})
ty
a
(lam [b _] (path [_] ty b a))
(abs [_] a)
b
p)
; auto
//; unfold J; reduce at left right; ?
}. | theorem | JInv | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Shannon :
(->
[ty : (-> bool (U 0))]
[elt : (-> [b : bool] ($ ty b))]
[b : bool]
(= ($ ty b) ($ elt b) (if [b] ($ ty b) b ($ elt tt) ($ elt ff)))) | by {
lam ty elt b =>
elim b; auto
}. | theorem | Shannon | example | example/tutorial.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Not :
(-> bool bool) | by {
?
}. | theorem | Not | example | example/tutorial1.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
NotNot :
(->
[b : bool]
(= bool ($ Not ($ Not b)) b)) | by {
?
}. | theorem | NotNot | example | example/tutorial1.prl | [] | [
"Not"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RespectEquality :
(->
[family : (-> [b : bool] (U 0))]
[b : bool]
($ family b)
($ family ($ Not ($ Not b)))) | by {
?
}. | theorem | RespectEquality | example | example/tutorial1.prl | [] | [
"Not"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EqualityIrrelevant :
(=
(-> [b : bool] (= bool ($ Not ($ Not b)) b))
NotNot
(lam [b] ax)) | by {
?
}. | theorem | EqualityIrrelevant | example | example/tutorial1.prl | [] | [
"Not",
"NotNot"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
FunToPairIsEquiv :
(->
[ty : (U 0 kan)]
(IsEquiv (-> bool ty) (* ty ty) ($ FunToPair ty))) | by {
lam ty pair =>
{ { lam b => if b then `(!proj1 pair) else `(!proj2 pair)
, abs _ => `pair }
, unfold Fiber;
lam {fun,p} =>
fresh x:dim -> refine path/intro; [
{lam b => if b then `(!proj1 (@ p x)) else `(!proj2 (@ p x)),
abs y =>
`(@ ($ (WeakConnection #lvl{0}) (* ty... | theorem | FunToPairIsEquiv | example | example/tutorial1.prl | [] | [
"Fiber",
"FunToPair",
"IsEquiv",
"WeakConnection"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Refl :
(->
[ty : (U 0)]
[a : ty]
(path [_] ty a a)) | by {
?
}. | theorem | Refl | example | example/tutorial2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
FunPath :
(->
[a b : (U 0)]
[f g : (-> a b)]
(path [_] (-> a b) f g)
[arg : a]
(path [_] b ($ f arg) ($ g arg))) | by {
?
}. | theorem | FunPath | example | example/tutorial2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathInv :
(->
[ty : (U 0 kan)]
[a b : ty]
[p : (path [_] ty a b)]
(path [_] ty b a)) | by {
// a -- x
// ------- |
// | | y
// p | | a
// | |
// b .... a
?
}. | theorem | PathInv | example | example/tutorial2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathConcat :
(->
[ty : (U 0 kan)]
[a b c : ty]
[p : (path [_] ty a b)]
[q : (path [_] ty b c)]
(path [_] ty a c)) | by {
// p -- x
// ------- |
// | | y
// a | | q
// | |
// a .... c
?
}. | theorem | PathConcat | example | example/tutorial2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
JInv :
(->
[ty : (U 0 kan)]
[a b : ty]
[p : (path [_] ty a b)]
(path [_] ty b a)) | by {
lam ty a b p =>
exact
($ (J #lvl{0})
ty
a
(lam [b _] (path [_] ty b a))
(abs [_] a)
b
p);
?
}. | theorem | JInv | example | example/tutorial2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
IsProp (#C) | = (-> [c c' : #C] (path [_] #C c c')). | define | IsProp | example | example/univalence.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
IsSet (#C) | = (-> [c c' : #C] (IsProp (path [_] #C c c'))). | define | IsSet | example | example/univalence.prl | [] | [
"IsProp"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Retract (#A,#f,#g) | = (-> [a : #A] (path [_] #A ($ #g ($ #f a)) a)). | define | Retract | example | example/univalence.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
IdEquiv(#l:lvl) :
(-> [ty : (U #l hcom)] (Equiv ty ty)) | by {
lam ty =>
{ lam a => use a
, lam a =>
{ {use a, abs _ => use a}
, lam {_,c'} => abs i =>
{`(hcom 1~>0 ty a [i=0 [j] (@ c' j)] [i=1 [j] a]),
abs j => `(hcom 1~>j ty a [i=0 [j] (@ c' j)] [i=1 [j] a])}
}
}
}. | theorem | IdEquiv | example | example/univalence.prl | [] | [
"Equiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UA(#l:lvl) :
(-> [ty/a ty/b : (U #l kan)]
[e : (Equiv ty/a ty/b)]
(path [_] (U #l kan) ty/a ty/b)) | by {
lam ty/a ty/b e =>
abs x => `(V x ty/a ty/b e)
}. | theorem | UA | example | example/univalence.prl | [] | [
"Equiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UABeta(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
[e : (Equiv ty/a ty/b)]
[a : ty/a]
(path [_] ty/b
(coe 0~>1 [x] (@ ($ (UA #l) ty/a ty/b e) x) a)
($ (!proj1 e) a))) | by {
unfold UA;
lam ty/a ty/b {f,_} a =>
abs x => `(coe x~>1 [_] ty/b ($ f a))
}. | theorem | UABeta | example | example/univalence.prl | [] | [
"Equiv",
"UA"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PathToEquiv(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
[p : (path [_] (U #l kan) ty/a ty/b)]
(Equiv ty/a ty/b)) | by {
lam ty/a ty/b p =>
`(coe 0~>1 [x] (Equiv ty/a (@ p x)) ($ (IdEquiv #l) ty/a))
}. | theorem | PathToEquiv | example | example/univalence.prl | [] | [
"Equiv",
"IdEquiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
LemPropF(#l:lvl) :
(->
[ty/a : (U #l kan)]
[ty/b : (-> ty/a (U #l kan))]
[prop/b : (-> [a : ty/a] (IsProp ($ ty/b a)))]
[p : (-> dim ty/a)]
[b0 : ($ ty/b (@ p 0))]
[b1 : ($ ty/b (@ p 1))]
(path [x] ($ ty/b (@ p x)) b0 b1)) | by {
lam ty/a ty/b prop/b p b0 b1 => abs x =>
use prop/b
[ use p [`x]
, `(coe 0~>x [i] ($ ty/b (@ p i)) b0)
, `(coe 1~>x [i] ($ ty/b (@ p i)) b1)
, `x
]
}. | theorem | LemPropF | example | example/univalence.prl | [] | [
"IsProp"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
LemSig(#l:lvl) :
(->
[ty/a : (U #l kan)]
[ty/b : (-> ty/a (U #l kan))]
[prop/b : (-> [a : ty/a] (IsProp ($ ty/b a)))]
[u v : (* [a : ty/a] ($ ty/b a))]
[p : (path [_] ty/a (!proj1 u) (!proj1 v))]
(path [_] (* [a : ty/a] ($ ty/b a)) u v)) | by {
lam ty/a ty/b prop/b {u1, u2} {v1, v2} p => abs x =>
{ use p [`x]
, use (LemPropF #l) [`ty/a, `ty/b, `prop/b, abs i => use p [`i], `u2, `v2, `x]
}
}. | theorem | LemSig | example | example/univalence.prl | [] | [
"IsProp",
"LemPropF"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropSig(#l:lvl) :
(->
[ty/a : (U #l kan)]
[ty/b : (-> ty/a (U #l kan))]
[prop/a : (IsProp ty/a)]
[prop/b : (-> [a : ty/a] (IsProp ($ ty/b a)))]
[u v : (* [a : ty/a] ($ ty/b a))]
(path [_] (* [a : ty/a] ($ ty/b a)) u v)) | by {
lam ty/a ty/b prop/a prop/b u v =>
use (LemSig #l)
[ `ty/a
, `ty/b
, `prop/b
, `u
, `v
, use prop/a [let {u1, _} = u; `u1, let {v1, _} = v; `v1]
]
}. | theorem | PropSig | example | example/univalence.prl | [] | [
"IsProp",
"LemSig"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropPi(#l:lvl) :
(->
[ty/a : (U #l kan)]
[ty/b : (-> ty/a (U #l kan))]
[prop/b : (-> [a : ty/a] (IsProp ($ ty/b a)))]
[f g : (-> [a : ty/a] ($ ty/b a))]
(path [_] (-> [a : ty/a] ($ ty/b a)) f g)) | by {
lam ty/a ty/b prop/b f g =>
abs x => lam a =>
use prop/b [`a, use f [`a], use g [`a], `x];
}. | theorem | PropPi | example | example/univalence.prl | [] | [
"IsProp"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
LemProp(#l:lvl) :
(->
[ty/a : (U #l kan)]
[prop/a : (IsProp ty/a)]
[a : ty/a]
(IsContr ty/a)) | by {
lam ty/a prop/a a =>
{`a , lam a' => use prop/a [`a', `a]}
}. | theorem | LemProp | example | example/univalence.prl | [] | [
"IsContr",
"IsProp"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropSet(#l:lvl) :
(->
[ty : (U #l kan)]
[prop : (IsProp ty)]
(IsSet ty)) | by {
unfold IsProp IsSet;
lam ty prop a b p q => abs x y =>
`(hcom 0~>1 ty a
[y=0 [z] (@ ($ prop a a) z)]
[y=1 [z] (@ ($ prop a b) z)]
[x=0 [z] (@ ($ prop a (@ p y)) z)]
[x=1 [z] (@ ($ prop a (@ q y)) z)])
}. | theorem | PropSet | example | example/univalence.prl | [] | [
"IsProp",
"IsSet"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropIsContr(#l:lvl) :
(->
[ty/a : (U #l kan)]
(IsProp (IsContr ty/a))) | by {
lam ty/a isContr =>
claim contr/a/prop : (IsProp (IsContr ty/a)) by {
let {_,contr} = isContr;
claim prop/a : (IsProp ty/a) by {
lam a a' => abs x =>
`(hcom 1~>0 ty/a (@ ($ contr a) x)
[x=0 [_] a]
[x=1 [y] (@ ($ contr a') y)])
};
use (PropSig... | theorem | PropIsContr | example | example/univalence.prl | [] | [
"IsContr",
"IsProp",
"PropPi",
"PropSet",
"PropSig"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropIsEquiv(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
[f : (-> ty/a ty/b)]
(IsProp (IsEquiv ty/a ty/b f))) | by {
lam ty/a ty/b f e0 e1 =>
abs x => lam b =>
use (PropIsContr #l)
[ `(Fiber ty/a ty/b f b)
, use e0 [`b]
, use e1 [`b]
, `x
]
}. | theorem | PropIsEquiv | example | example/univalence.prl | [] | [
"Fiber",
"IsEquiv",
"IsProp",
"PropIsContr"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EquivLemma(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
[e1 e2 : (Equiv ty/a ty/b)]
(path [_] (-> ty/a ty/b) (!proj1 e1) (!proj1 e2))
(path [_] (Equiv ty/a ty/b) e1 e2)) | by {
lam ty/a ty/b =>
use (LemSig #l)
[ `(-> ty/a ty/b)
, lam f => `(IsEquiv ty/a ty/b f)
, use (PropIsEquiv #l) [`ty/a, `ty/b]
]
}. | theorem | EquivLemma | example | example/univalence.prl | [] | [
"Equiv",
"IsEquiv",
"LemSig",
"PropIsEquiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UARet(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
(Retract
(Equiv ty/a ty/b)
($ (UA #l) ty/a ty/b)
($ (PathToEquiv #l) ty/a ty/b))) | by {
lam ty/a ty/b e =>
use (EquivLemma #l)
[ `ty/a
, `ty/b
, use (PathToEquiv #l) [`ty/a, `ty/b, use (UA #l) [`ty/a, `ty/b, `e]]
, `e
, abs x => lam a =>
use (UABeta #l) [`ty/a, `ty/b, `e, `(coe 1~>x [_] ty/a a), `x]
];
unfold PathToEquiv at right in concl; au... | theorem | UARet | example | example/univalence.prl | [] | [
"Equiv",
"EquivLemma",
"PathToEquiv",
"Retract",
"UA",
"UABeta"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
IsContrPath(#l:lvl) :
(->
[ty/a : (U #l kan)]
(IsContr (* [ty/b : (U #l kan)] (path [_] (U #l kan) ty/a ty/b)))) | by {
lam ty/a =>
{ {use ty/a, abs _ => use ty/a},
lam {ty/b,p} => abs x =>
{ `(hcom 0~>1 (U #l kan) ty/a [x=0 [y] (@ p y)] [x=1 [_] ty/a])
, abs y => `(hcom 0~>y (U #l kan) ty/a [x=0 [y] (@ p y)] [x=1 [_] ty/a])
}
}
}. | theorem | IsContrPath | example | example/univalence.prl | [] | [
"IsContr"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RetIsContr(#l:lvl) :
(->
[ty/a ty/b : (U #l kan)]
[f : (-> ty/a ty/b)]
[g : (-> ty/b ty/a)]
[h : (-> [a : ty/a] (path [_] ty/a ($ g ($ f a)) a))]
[contr/b : (IsContr ty/b)]
(IsContr ty/a)) | by {
lam ty/a ty/b f g h {b,p} =>
{`($ g b),
lam a => abs x =>
`(hcom 0~>1 ty/a ($ g (@ ($ p ($ f a)) x))
[x=0 [y] (@ ($ h a) y)]
[x=1 [_] ($ g b)])}
}. | theorem | RetIsContr | example | example/univalence.prl | [] | [
"IsContr"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
SigEquivToPath(#l:lvl) :
(->
[ty/a : (U #l kan)]
(* [ty/b : (U #l kan)] (Equiv ty/a ty/b))
(* [ty/b : (U #l kan)] (path [_] (U #l kan) ty/a ty/b))) | by {
lam ty/a {ty/b,equiv} =>
{ use ty/b
, abs x => `(V x ty/a ty/b equiv)
}
}. | theorem | SigEquivToPath | example | example/univalence.prl | [] | [
"Equiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
SigPathToEquiv(#l:lvl) :
(->
[ty/a : (U #l kan)]
(* [ty/b : (U #l kan)] (path [_] (U #l kan) ty/a ty/b))
(* [ty/b : (U #l kan)] (Equiv ty/a ty/b))) | by {
lam ty/a {ty/b,p} =>
{ use ty/b
, use (PathToEquiv #l) [`ty/a, `ty/b, `p]
}
}. | theorem | SigPathToEquiv | example | example/univalence.prl | [] | [
"Equiv",
"PathToEquiv"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UARetSig(#l:lvl) :
(->
[ty/a : (U #l kan)]
(Retract
(* [ty/b : (U #l kan)] (Equiv ty/a ty/b))
($ (SigEquivToPath #l) ty/a)
($ (SigPathToEquiv #l) ty/a))) | by {
lam ty/a {ty/b,equiv} =>
unfold SigPathToEquiv SigEquivToPath;
abs x =>
{ use ty/b
, use (UARet #l) [`ty/a, `ty/b, `equiv, `x]
}
}. | theorem | UARetSig | example | example/univalence.prl | [] | [
"Equiv",
"Retract",
"SigEquivToPath",
"SigPathToEquiv",
"UARet"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Univalence(#l:lvl) :
(->
[ty/a : (U #l kan)]
(IsContr (* [ty/b : (U #l kan)] (Equiv ty/a ty/b)))) | by {
lam ty/a =>
use (RetIsContr (++ #l))
[ `(* [ty/b : (U #l kan)] (Equiv ty/a ty/b))
, `(* [ty/b : (U #l kan)] (path [_] (U #l kan) ty/a ty/b))
, use (SigEquivToPath #l) [`ty/a]
, use (SigPathToEquiv #l) [`ty/a]
, use (UARetSig #l) [`ty/a]
, use (IsContrPath #l) [`ty/a]
]
}. | theorem | Univalence | example | example/univalence.prl | [] | [
"Equiv",
"IsContr",
"IsContrPath",
"RetIsContr",
"SigEquivToPath",
"SigPathToEquiv",
"UARetSig"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
MalformedTube :
wbool true | by {
`(hcom 0~>1 wbool tt)
}. | theorem | MalformedTube | test/failure | test/failure/bad-hcom-empty.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Bool :
wbool true | by {
`(hcom 0~>1 wbool tt [0=1 [_] tt]);
auto
}. | theorem | Bool | test/failure | test/failure/bad-hcom-stuck.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Foo(#a : exp, #b : exp) : exp | = (-> #a #b) . | define | Foo | test/failure | test/failure/bad-op.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Foo-bool-type : (Foo bool) typeby {
auto
}. | theorem | Foo-bool-type | test/failure | test/failure/bad-op.prl | [] | [
"Foo"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | ||
Cmp(#f : exp, #g : exp) : exp | =
(lam [x] ($ #f ($ #h x)))
. | define | Cmp | test/failure | test/failure/freemeta.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
FreeVar : x true | by {
auto
}. | theorem | FreeVar | test/failure | test/failure/freevar.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Foo : tt = tt in bool | by {
auto
}. | theorem | Foo | test/failure | test/failure/incremental-parse.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Bar : tt = tt in bool ] by {
auto
}.
Thm Baz : [ tt = tt in bool | by {
auto
}. | theorem | Bar | test/failure | test/failure/incremental-parse.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Path/Symm(#l:lvl) :
ty : (U #l)
>>
ty type with hcom | by {
auto
}. | theorem | Path/Symm | test/failure | test/failure/kind-hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
LexicalError : (-> bool bool) true | by {
(lam x => `_tt); auto
}. | theorem | LexicalError | test/failure | test/failure/lexical-error.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
NegOne :
-1 in nat | by {
auto
}. | theorem | NegOne | test/failure | test/failure/num.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RecordTest :
tuple in (record [a : bool]) | by {
auto
}. | theorem | RecordTest | test/failure | test/failure/record0.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RecordTest :
(! a tuple) in bool | by {
auto
}. | theorem | RecordTest | test/failure | test/failure/record1.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
RecordTest :
(! a (tuple [b tt])) in bool | by {
auto
}. | theorem | RecordTest | test/failure | test/failure/record2.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
DuplicateLabel :
(tuple [a tt]) in (record [a a : bool]) | by {
auto
}. | theorem | DuplicateLabel | test/failure | test/failure/record3.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
DuplicateLabel :
(tuple [a tt] [a tt]) in (record [a : bool]) | by {
auto
}. | theorem | DuplicateLabel | test/failure | test/failure/record4.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Not : exp | =
(lam [x] (if x ff tt))
. | define | Not | test/failure | test/failure/undef-custom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Foo : Bar = Bar in bool | by {
auto
}. | theorem | Foo | test/failure | test/failure/undef-custom.prl | [] | [
"Bar"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Test : (* bool bool) = (* bool bool) type | by {
auto
}. | theorem | Test | test/success | test/success/bool-pair-test.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Ident-test/ : bool | by {
`tt
}. | theorem | Ident-test/ | test/success | test/success/dashes-n-slashes.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Decomposition :
(->
(record [rcd : (record [a : bool] [b : (* bool int)])] [circ : S1])
bool) | by {
lam x =>
let {rcd = {a = a, b = {welp}}, circ = circ} = x;
use welp
}. | theorem | Decomposition | test/success | test/success/decomposition.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Apply :
(->
(->
bool
bool
(path [_]
(record [a : S1])
(tuple [a base])
(tuple [a base])))
S1) | by {
lam f =>
let {a = a} = f [`tt, `ff, `(dim 0)];
use a
}. | theorem | Apply | test/success | test/success/decomposition.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UseHypTest :
(-> bool bool) | by {
lam x =>
claim p : (-> bool S1 bool) by {lam b c => use b};
use p [use x, `(loop 0)]
}. | theorem | UseHypTest | test/success | test/success/decomposition.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
UseLemmaTest :
(-> bool bool) | by {
lam x =>
use UseHypTest [use x]
}. | theorem | UseLemmaTest | test/success | test/success/decomposition.prl | [] | [
"UseHypTest"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Discrete/reflection(#l:lvl) :
(->
[ty : (U #l discrete)]
[a b : ty]
[p : (path [_] ty a b)]
(= ty a b)) | by {
lam ty a b p => `(coe 0~>1 [x] (= ty a (@ p x)) ax)
}. | theorem | Discrete/reflection | test/success | test/success/discrete-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
GetHole(#c : [exp].exp, #t : [exp].tac) | = {
query gl <- concl;
match gl {
[hole | #jdg{(#c %hole)} => (#t %hole)]
}
}. | tactic | GetHole | test/success | test/success/equality-elim.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Rewrite(#c : [exp].exp, #n, #a, #t : tac) | = {
(GetHole [x] (#c x) [hole] #tac{
claim p : hole = #n in #a by {#t};
// Use the elimination rule for equality. We bind a new hypothesis which will represent the location
// in the goal #c which is being rewritten.
rewrite p;
[with x => `(#c x), id, auto, auto]
})
}. | tactic | Rewrite | test/success | test/success/equality-elim.prl | [] | [
"GetHole"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EqualityElimTest :
(-> [b : bool] (path [_] bool tt (if [_] bool tt tt ff))) | by {
// We're going to prove this in a silly way to illustrate equality elimination.
// We'll rewrite the goal by claiming (if tt tt ff) = tt in bool.
(Rewrite
[x] (-> bool (path [_] bool tt x))
tt bool #tac{auto});
// observe that the goal has now been rewritten!
?check-this-out;
lam b => abs _ => ... | theorem | EqualityElimTest | test/success | test/success/equality-elim.prl | [] | [
"Rewrite"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EqualityKind0(#A) :
(->
[ty : (U 0 pre)]
[a b : ty]
(= (U 0 hcom) (= ty a b) (= ty a b))) | by {
lam ty a b => auto
}. | theorem | EqualityKind0 | test/success | test/success/equality.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
EqualityKind1(#A) :
(->
[ty : (U 0 discrete)]
[a b : ty]
(= (U 0 kan) (= ty a b) (= ty a b))) | by {
lam ty a b => auto
}. | theorem | EqualityKind1 | test/success | test/success/equality.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Fcom/bool :
(-> [i : dim]
(mem (U 0) (fcom 0~>1 bool [i=0 [j] bool] [i=1 [j] bool]))) | by {
abs i => auto
}. | theorem | Fcom/bool | test/success | test/success/fcom-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Fcom/Box :
(-> [i : dim]
(mem
(fcom 0~>1 bool [i=0 [j] bool] [i=1 [j] bool])
(box 0~>1 tt [i=0 tt] [i=1 tt]))) | by {
abs i => auto
}. | theorem | Fcom/Box | test/success | test/success/fcom-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Fcom/Reduce :
(fcom 0~>1 bool [0=0 [j] bool]) = bool type | by {
auto
}. | theorem | Fcom/Reduce | test/success | test/success/fcom-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Fcom/Cap1 :
tt in (fcom 0~>1 bool [0=0 [j] bool]) | by {
auto
}. | theorem | Fcom/Cap1 | test/success | test/success/fcom-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Fcom/Cap2 :
(cap 0<~1 (box 0~>1 tt [0=0 tt]) [0=0 [j] bool]) in bool | by {
auto
}. | theorem | Fcom/Cap2 | test/success | test/success/fcom-types.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Hcom/Poly(#l:lvl) :
(->
[ty : (U #l hcom)]
[a b c d : ty]
(path [_] ty a b)
(path [_] ty a c)
(path [_] ty b d)
(path [_] ty c d)) | by {
lam ty a b c d pab pac pbd =>
abs i =>
`(hcom 0~>1 ty (@ pab i)
[i=0 [j] (@ pac j)]
[i=1 [j] (@ pbd j)])
}. | theorem | Hcom/Poly | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Hcom/trans(#l:lvl) :
(->
[ty : (U #l hcom)]
[a b c : ty]
(path [_] ty a b)
(path [_] ty b c)
(path [_] ty a c)) | by {
lam ty a b c pab pbc =>
abs i =>
`(hcom 0 ~> 1 ty (@ pab i)
[i=0 [_] a]
[i=1 [j] (@ pbc j)])
}. | theorem | Hcom/trans | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Hcom/symm(#l:lvl) :
(->
[ty : (U #l hcom)]
[a b : ty]
(path [_] ty a b)
(path [_] ty b a)) | by {
lam ty a b pab =>
abs i =>
`(hcom 0~>1 ty a
[i=0 [j] (@ pab j)]
[i=1 [_] a])
}. | theorem | Hcom/symm | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Cap(#l:lvl) :
(->
[ty : (U #l hcom)]
[x : ty]
[i : dim]
(= ty
(hcom 0~>0 ty x [i=0 [_] x] [i=1 [_] x])
x)) | by {
lam ty x => abs i => auto
}. | theorem | Cap | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Tube(#l:lvl) :
(->
[ty : (U #l hcom)]
[x : ty]
(= ty
(hcom 0~>1 ty x [1=1 [_] x] [0=0 [_] x])
x)) | by {
lam ty x => auto
}. | theorem | Tube | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
TrueByEvaluation :
(hcom 0~>0 bool tt) in bool | by {
auto
}. | theorem | TrueByEvaluation | test/success | test/success/hcom.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Loop' :
(path [_] (. S1' type) (. S1' base') (. S1' base')) | by {
abs u => `(. S1' loop' u)
}. | theorem | Loop' | test/success | test/success/inductive-S1.prl | [] | [
"S1'"
] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Pushout' (#l:lvl)
[a b c : (U #l coe)]
[f : (-> c a)]
[g : (-> c b)]
: (U #l kan)
{ left' a
, right' b
, glue' [x : c] [y : dim] [y=0 (self left' ($ f x))] [y=1 (self right' ($ g x))]
} | by {
auto
}. | data | Pushout' | test/success | test/success/inductive.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
PropTrunc (#l:lvl) [a : (U 0 coe)] : (U 0 kan) {
pt a,
sq [x y : self] [z : dim] [z=0 x] [z=1 y]
} | by { auto }. | data | PropTrunc | test/success | test/success/inductive.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c | |
Line/Test0 :
(->
[a : (U 0 kan)]
[l : (-> dim a)]
(= a (coe 0~>1 [_] a (@ l 0)) (@ (coe 0~>1 [_] (-> dim a) l) 0))) | by {
lam a l => `ax
}. | theorem | Line/Test0 | test/success | test/success/lines.prl | [] | [] | https://github.com/RedPRL/sml-redprl | c72190de76f7ed1cfbe1d2046c96e99ac5022b0c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.