2022-04-27 14:06:39 -04:00
|
|
|
|
module Tests.Equal
|
|
|
|
|
|
2023-02-11 12:15:50 -05:00
|
|
|
|
import Quox.Equal
|
2023-01-08 14:44:25 -05:00
|
|
|
|
import Quox.Syntax.Qty.Three
|
2023-02-11 12:15:50 -05:00
|
|
|
|
import public TypingImpls
|
2022-04-27 14:06:39 -04:00
|
|
|
|
import TAP
|
|
|
|
|
|
2023-01-08 14:44:25 -05:00
|
|
|
|
0 M : Type -> Type
|
|
|
|
|
M = ReaderT (Definitions Three) (Either (Error Three))
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
2023-02-10 15:40:44 -05:00
|
|
|
|
defGlobals : Definitions Three
|
|
|
|
|
defGlobals = fromList
|
|
|
|
|
[("A", mkAbstract Zero $ TYPE 0),
|
|
|
|
|
("B", mkAbstract Zero $ TYPE 0),
|
|
|
|
|
("a", mkAbstract Any $ FT "A"),
|
2023-02-11 12:15:50 -05:00
|
|
|
|
("a'", mkAbstract Any $ FT "A"),
|
2023-02-10 15:40:44 -05:00
|
|
|
|
("b", mkAbstract Any $ FT "B"),
|
|
|
|
|
("f", mkAbstract Any $ Arr One (FT "A") (FT "A"))]
|
|
|
|
|
|
2022-08-22 23:43:23 -04:00
|
|
|
|
parameters (label : String) (act : Lazy (M ()))
|
2023-02-10 15:40:44 -05:00
|
|
|
|
{default defGlobals globals : Definitions Three}
|
2022-08-22 23:43:23 -04:00
|
|
|
|
testEq : Test
|
|
|
|
|
testEq = test label $ runReaderT globals act
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
2022-08-22 23:43:23 -04:00
|
|
|
|
testNeq : Test
|
|
|
|
|
testNeq = testThrows label (const True) $ runReaderT globals act
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
|
|
|
|
|
2023-01-22 18:53:34 -05:00
|
|
|
|
parameters {default 0 d, n : Nat}
|
|
|
|
|
{default new eqs : DimEq d}
|
2023-02-10 15:40:44 -05:00
|
|
|
|
(ctx : TContext Three d n)
|
|
|
|
|
subT : Term Three d n -> Term Three d n -> Term Three d n -> M ()
|
|
|
|
|
subT ty s t = Term.sub eqs ctx ty s t
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT : Term Three d n -> Term Three d n -> Term Three d n -> M ()
|
|
|
|
|
equalT ty s t = Term.equal eqs ctx ty s t
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
2023-01-22 18:53:34 -05:00
|
|
|
|
subE : Elim Three d n -> Elim Three d n -> M ()
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE e f = Elim.sub eqs ctx e f
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
2023-01-22 18:53:34 -05:00
|
|
|
|
equalE : Elim Three d n -> Elim Three d n -> M ()
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE e f = Elim.equal eqs ctx e f
|
2022-04-27 14:06:39 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
export
|
|
|
|
|
tests : Test
|
|
|
|
|
tests = "equality & subtyping" :- [
|
2023-01-22 18:53:34 -05:00
|
|
|
|
note #""0=1 ⊢ 𝒥" means that 𝒥 holds in an inconsistent dim context"#,
|
2023-02-11 12:15:50 -05:00
|
|
|
|
note #""s{…}" for term substs; "s‹…›" for dim substs"#,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
|
|
|
|
|
"universes" :- [
|
|
|
|
|
testEq "★₀ ≡ ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 1) (TYPE 0) (TYPE 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "★₀ ≢ ★₁" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2) (TYPE 0) (TYPE 1),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "★₁ ≢ ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2) (TYPE 1) (TYPE 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ <: ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 1) (TYPE 0) (TYPE 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ <: ★₁" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 2) (TYPE 0) (TYPE 1),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "★₁ ≮: ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 2) (TYPE 1) (TYPE 0)
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
|
|
|
|
"pi" :- [
|
2023-02-11 12:15:50 -05:00
|
|
|
|
note #""A ⊸ B" for (1·A) → B"#,
|
|
|
|
|
note #""A ⇾ B" for (0·A) → B"#,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A ⊸ B ≡ A ⊸ B" $
|
|
|
|
|
let tm = Arr One (FT "A") (FT "B") in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 0) tm tm,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "A ⇾ B ≢ A ⊸ B" $
|
|
|
|
|
let tm1 = Arr Zero (FT "A") (FT "B")
|
|
|
|
|
tm2 = Arr One (FT "A") (FT "B") in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 0) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "0=1 ⊢ A ⇾ B ≢ A ⊸ B" $
|
|
|
|
|
let tm1 = Arr Zero (FT "A") (FT "B")
|
|
|
|
|
tm2 = Arr One (FT "A") (FT "B") in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 0) tm1 tm2 {eqs = ZeroIsOne},
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A ⊸ B <: A ⊸ B" $
|
|
|
|
|
let tm = Arr One (FT "A") (FT "B") in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 0) tm tm,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "A ⇾ B ≮: A ⊸ B" $
|
|
|
|
|
let tm1 = Arr Zero (FT "A") (FT "B")
|
|
|
|
|
tm2 = Arr One (FT "A") (FT "B") in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 0) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ ⇾ ★₀ ≡ ★₀ ⇾ ★₀" $
|
|
|
|
|
let tm = Arr Zero (TYPE 0) (TYPE 0) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 1) tm tm,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ ⇾ ★₀ <: ★₀ ⇾ ★₀" $
|
|
|
|
|
let tm = Arr Zero (TYPE 0) (TYPE 0) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 1) tm tm,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "★₁ ⊸ ★₀ ≢ ★₀ ⇾ ★₀" $
|
|
|
|
|
let tm1 = Arr Zero (TYPE 1) (TYPE 0)
|
|
|
|
|
tm2 = Arr Zero (TYPE 0) (TYPE 0) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₁ ⊸ ★₀ <: ★₀ ⊸ ★₀" $
|
|
|
|
|
let tm1 = Arr One (TYPE 1) (TYPE 0)
|
|
|
|
|
tm2 = Arr One (TYPE 0) (TYPE 0) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 2) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "★₀ ⊸ ★₀ ≢ ★₀ ⇾ ★₁" $
|
|
|
|
|
let tm1 = Arr Zero (TYPE 0) (TYPE 0)
|
|
|
|
|
tm2 = Arr Zero (TYPE 0) (TYPE 1) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ ⊸ ★₀ <: ★₀ ⊸ ★₁" $
|
|
|
|
|
let tm1 = Arr One (TYPE 0) (TYPE 0)
|
|
|
|
|
tm2 = Arr One (TYPE 0) (TYPE 1) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 2) tm1 tm2,
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "★₀ ⊸ ★₀ <: ★₀ ⊸ ★₁" $
|
|
|
|
|
let tm1 = Arr One (TYPE 0) (TYPE 0)
|
|
|
|
|
tm2 = Arr One (TYPE 0) (TYPE 1) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (TYPE 2) tm1 tm2
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
|
|
|
|
"lambda" :- [
|
|
|
|
|
testEq "λ x ⇒ [x] ≡ λ x ⇒ [x]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ BVT 0)
|
|
|
|
|
(["x"] :\\ BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "λ x ⇒ [x] <: λ x ⇒ [x]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subT [<] (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ BVT 0)
|
|
|
|
|
(["x"] :\\ BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "λ x ⇒ [x] ≡ λ y ⇒ [y]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ BVT 0)
|
|
|
|
|
(["y"] :\\ BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "λ x ⇒ [x] <: λ y ⇒ [y]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ BVT 0)
|
|
|
|
|
(["y"] :\\ BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "λ x y ⇒ [x] ≢ λ x y ⇒ [y]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr One (FT "A") $ Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x", "y"] :\\ BVT 1)
|
|
|
|
|
(["x", "y"] :\\ BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "λ x ⇒ [a] ≡ λ x ⇒ [a] (TUsed vs TUnused)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr Zero (FT "B") (FT "A"))
|
|
|
|
|
(Lam "x" $ TUsed $ FT "a")
|
|
|
|
|
(Lam "x" $ TUnused $ FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "λ x ⇒ [f [x]] ≡ [f] (η)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ E (F "f" :@ BVT 0))
|
2023-02-10 15:40:44 -05:00
|
|
|
|
(FT "f")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
2023-01-26 13:54:46 -05:00
|
|
|
|
"eq type" :- [
|
|
|
|
|
testEq "(★₀ = ★₀ : ★₁) ≡ (★₀ = ★₀ : ★₁)" $
|
|
|
|
|
let tm = Eq0 (TYPE 1) (TYPE 0) (TYPE 0) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2) tm tm,
|
2023-01-26 13:54:46 -05:00
|
|
|
|
testEq "A ≔ ★₁ ⊢ (★₀ = ★₀ : ★₁) ≡ (★₀ = ★₀ : A)"
|
|
|
|
|
{globals = fromList [("A", mkDef zero (TYPE 2) (TYPE 1))]} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 2)
|
|
|
|
|
(Eq0 (TYPE 1) (TYPE 0) (TYPE 0))
|
|
|
|
|
(Eq0 (FT "A") (TYPE 0) (TYPE 0))
|
2023-01-26 13:54:46 -05:00
|
|
|
|
],
|
|
|
|
|
|
2023-02-11 12:15:50 -05:00
|
|
|
|
"equalities" :-
|
|
|
|
|
let refl : Term q d n -> Term q d n -> Elim q d n
|
|
|
|
|
refl a x = (DLam "_" $ DUnused x) :# (Eq0 a x x)
|
|
|
|
|
in
|
|
|
|
|
[
|
|
|
|
|
note #""refl [A] x" is an abbreviation for "(λᴰi ⇒ x) ∷ (x ≡ x : A)""#,
|
|
|
|
|
testEq "refl [A] a ≡ refl [A] a" $
|
|
|
|
|
equalE [<] (refl (FT "A") (FT "a")) (refl (FT "A") (FT "a")),
|
|
|
|
|
testEq "p : (a ≡ a' : A), q : (a ≡ a' : A) ⊢ p ≡ q (free)"
|
|
|
|
|
{globals =
|
|
|
|
|
let def = mkAbstract Zero $ Eq0 (FT "A") (FT "a") (FT "a'") in
|
|
|
|
|
defGlobals `mergeLeft` fromList [("p", def), ("q", def)]} $
|
|
|
|
|
equalE [<] (F "p") (F "q"),
|
|
|
|
|
testEq "x : (a ≡ a' : A), y : (a ≡ a' : A) ⊢ x ≡ y (bound)" $
|
|
|
|
|
let ty : forall n. Term Three 0 n := Eq0 (FT "A") (FT "a") (FT "a'") in
|
|
|
|
|
equalE [< ty, ty] (BV 0) (BV 1) {n = 2}
|
|
|
|
|
],
|
2023-01-26 13:54:46 -05:00
|
|
|
|
|
2023-01-22 18:53:34 -05:00
|
|
|
|
"term closure" :- [
|
|
|
|
|
note "𝑖, 𝑗 for bound variables pointing outside of the current expr",
|
|
|
|
|
testEq "[𝑖]{} ≡ [𝑖]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [< FT "A"] (FT "A") {n = 1}
|
|
|
|
|
(CloT (BVT 0) id)
|
|
|
|
|
(BVT 0),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "[𝑖]{a/𝑖} ≡ [a]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (FT "A")
|
|
|
|
|
(CloT (BVT 0) (F "a" ::: id))
|
|
|
|
|
(FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "[𝑖]{a/𝑖,b/𝑗} ≡ [a]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (FT "A")
|
|
|
|
|
(CloT (BVT 0) (F "a" ::: F "b" ::: id))
|
|
|
|
|
(FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "(λy. [𝑖]){y/y, a/𝑖} ≡ λy. [a] (TUnused)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr Zero (FT "B") (FT "A"))
|
|
|
|
|
(CloT (Lam "y" $ TUnused $ BVT 0) (F "a" ::: id))
|
|
|
|
|
(Lam "y" $ TUnused $ FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "(λy. [𝑖]){y/y, a/𝑖} ≡ λy. [a] (TUsed)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (Arr Zero (FT "B") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(CloT (["y"] :\\ BVT 1) (F "a" ::: id))
|
|
|
|
|
(["y"] :\\ FT "a")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
|
|
|
|
todo "term d-closure",
|
|
|
|
|
|
|
|
|
|
"free var" :-
|
|
|
|
|
let au_bu = fromList
|
|
|
|
|
[("A", mkDef Any (TYPE (U 1)) (TYPE (U 0))),
|
|
|
|
|
("B", mkDef Any (TYPE (U 1)) (TYPE (U 0)))]
|
|
|
|
|
au_ba = fromList
|
|
|
|
|
[("A", mkDef Any (TYPE (U 1)) (TYPE (U 0))),
|
|
|
|
|
("B", mkDef Any (TYPE (U 1)) (FT "A"))]
|
|
|
|
|
in [
|
|
|
|
|
testEq "A ≡ A" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "A") (F "A"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "A ≢ B" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "0=1 ⊢ A ≡ B" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE {eqs = ZeroIsOne} [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A : ★₁ ≔ ★₀ ⊢ A ≡ (★₀ ∷ ★₁)" {globals = au_bu} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "A") (TYPE 0 :# TYPE 1),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A ≔ ★₀, B ≔ ★₀ ⊢ A ≡ B" {globals = au_bu} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A ≔ ★₀, B ≔ A ⊢ A ≡ B" {globals = au_ba} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A <: A" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "A") (F "A"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "A ≮: B" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A : ★₃ ≔ ★₀, B : ★₃ ≔ ★₂ ⊢ A <: B"
|
|
|
|
|
{globals = fromList [("A", mkDef Any (TYPE 3) (TYPE 0)),
|
|
|
|
|
("B", mkDef Any (TYPE 3) (TYPE 2))]} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "A : ★₁👈 ≔ ★₀, B : ★₃ ≔ ★₂ ⊢ A <: B"
|
|
|
|
|
{globals = fromList [("A", mkDef Any (TYPE 1) (TYPE 0)),
|
|
|
|
|
("B", mkDef Any (TYPE 3) (TYPE 2))]} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "A") (F "B"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "0=1 ⊢ A <: B" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "A") (F "B") {eqs = ZeroIsOne}
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
|
|
|
|
"bound var" :- [
|
|
|
|
|
note "𝑖, 𝑗 for distinct bound variables",
|
|
|
|
|
testEq "𝑖 ≡ 𝑖" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [< TYPE 0] (BV 0) (BV 0) {n = 1},
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testNeq "𝑖 ≢ 𝑗" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [< TYPE 0, TYPE 0] (BV 0) (BV 1) {n = 2},
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "0=1 ⊢ 𝑖 ≡ 𝑗" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [< TYPE 0, TYPE 0] (BV 0) (BV 1)
|
|
|
|
|
{n = 2, eqs = ZeroIsOne}
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
|
|
|
|
"application" :- [
|
|
|
|
|
testEq "f [a] ≡ f [a]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "f" :@ FT "a") (F "f" :@ FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "f [a] <: f [a]" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<] (F "f" :@ FT "a") (F "f" :@ FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "(λ x ⇒ [x] ∷ A ⊸ A) a ≡ ([a ∷ A] ∷ A) (β)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<]
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(((["x"] :\\ BVT 0) :# Arr One (FT "A") (FT "A")) :@ FT "a")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
(E (FT "a" :# FT "A") :# FT "A"),
|
|
|
|
|
testEq "(λ x ⇒ [x] ∷ A ⊸ A) a ≡ a (βυ)" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<]
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(((["x"] :\\ BVT 0) :# Arr One (FT "A") (FT "A")) :@ FT "a")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
(F "a"),
|
2023-02-10 15:40:44 -05:00
|
|
|
|
testEq "(λ g ⇒ [g [a]] ∷ ⋯)) [f] ≡ (λ y ⇒ [f [y]] ∷ ⋯) [a] (β↘↙)" $
|
2023-01-22 18:53:34 -05:00
|
|
|
|
let a = FT "A"; a2a = (Arr One a a) in
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<]
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(((["g"] :\\ E (BV 0 :@ FT "a")) :# Arr One a2a a) :@ FT "f")
|
|
|
|
|
(((["y"] :\\ E (F "f" :@ BVT 0)) :# a2a) :@ FT "a"),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "(λ x ⇒ [x] ∷ A ⊸ A) a <: a" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
subE [<]
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(((["x"] :\\ BVT 0) :# (Arr One (FT "A") (FT "A"))) :@ FT "a")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
(F "a"),
|
2023-02-10 15:40:44 -05:00
|
|
|
|
testEq "id : A ⊸ A ≔ λ x ⇒ [x] ⊢ id [a] ≡ a"
|
|
|
|
|
{globals = defGlobals `mergeLeft` fromList
|
|
|
|
|
[("id", mkDef Any (Arr One (FT "A") (FT "A"))
|
2023-02-11 12:15:50 -05:00
|
|
|
|
(["x"] :\\ BVT 0))]} $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalE [<] (F "id" :@ FT "a") (F "a")
|
2023-01-22 18:53:34 -05:00
|
|
|
|
],
|
|
|
|
|
|
2023-02-11 12:15:50 -05:00
|
|
|
|
todo "dim application",
|
2023-01-26 13:54:46 -05:00
|
|
|
|
|
2023-01-22 18:53:34 -05:00
|
|
|
|
todo "annotation",
|
|
|
|
|
|
|
|
|
|
todo "elim closure",
|
|
|
|
|
|
|
|
|
|
todo "elim d-closure",
|
|
|
|
|
|
|
|
|
|
"clashes" :- [
|
|
|
|
|
testNeq "★₀ ≢ ★₀ ⇾ ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 1) (TYPE 0) (Arr Zero (TYPE 0) (TYPE 0)),
|
2023-01-22 18:53:34 -05:00
|
|
|
|
testEq "0=1 ⊢ ★₀ ≡ ★₀ ⇾ ★₀" $
|
2023-02-10 15:40:44 -05:00
|
|
|
|
equalT [<] (TYPE 1) (TYPE 0) (Arr Zero (TYPE 0) (TYPE 0))
|
|
|
|
|
{eqs = ZeroIsOne},
|
2023-01-22 18:53:34 -05:00
|
|
|
|
todo "others"
|
2022-04-27 14:06:39 -04:00
|
|
|
|
]
|
2023-01-22 18:53:34 -05:00
|
|
|
|
]
|