Question

我正在构建一个有点依赖类型的lambda演算解释器：

import Data.Vect

%default total

{- fin helper functions and lemmas -}

incrFin : Fin n -> Fin (S n) -> Fin (S n)
incrFin x FZ = FS x
incrFin FZ (FS y) = FZ
incrFin (FS x) (FS y) = FS (incrFin x y)

subrFin : (x : Fin (S n)) -> (y : Fin (S n)) -> (x = y -> Void) -> Fin n
subrFin FZ FZ neq = absurd (neq Refl)
subrFin FZ (FS x) neq = x
subrFin {n = S n} (FS x) FZ neq = FZ
subrFin {n = S n} (FS x) (FS y) neq = FS (subrFin x y (\Refl => neq Refl))

indexOfIncrFin : (x : Fin (S n)) -> (y : Fin n) -> (env : Vect n a) -> (t : a) ->
  index (incrFin y x) (insertAt x t env) = index y env
{- elided -}

indexOfSubrFin : {n : Nat} -> {env : Vect n a} -> (neq : (x = y) -> Void) ->
  index (subrFin x y neq) env = index y (insertAt x t2 env)
{- elided -}

indexInsertAt : (x : Fin (S n)) -> (t : a) -> (env : Vect n a) -> index x (insertAt x t env) = t
{- elided -}

incrFinChanges : (x : Fin n) -> (y : Fin (S n)) -> Not (incrFin x y = y)
{- elided -}

{- main code -}

data Ty = Base | Arrow Ty Ty

data Expr : Vect n Ty -> Ty -> Type where
  Var : (x : Fin n) -> index x env = t -> Expr env t
  Con : Expr env Base
  App : Expr env (Arrow t1 t2) -> Expr env t1 -> Expr env t2
  Abs : (t1 : Ty) -> Expr (t1 :: env) t2 -> Expr env (Arrow t1 t2)

incr : (x : Fin (S n)) -> (tt : Ty) -> Expr env t -> Expr (insertAt x tt env) t
incr x tt (Var y Refl) {env = env} = Var (incrFin y x) (indexOfIncrFin x y env tt)
incr x tt Con = Con
incr x tt (App e1 e2) = App (incr x tt e1) (incr x tt e2)
incr x tt (Abs t1 e) = Abs t1 (incr (FS x) tt e)

subst : (x : Fin (S n)) -> Expr env t' -> Expr (insertAt x t' env) t -> Expr env t
subst {env = env} {t' = t'} x e' (Var y pf) with (decEq x y)
  subst {env = env} {t' = t'} x e' (Var x Refl) | Yes Refl = rewrite indexInsertAt x t' env in e'
  subst {env = env} {t' = t'} x e' (Var y Refl) | No neq = Var (subrFin x y neq) (indexOfSubrFin neq)
subst x e' Con = Con
subst x e' (App e1 e2) = App (subst x e' e1) (subst x e' e2)
subst x e' (Abs t1 e) = Abs t1 (subst (FS x) (incr FZ t1 e') e)

substIncr : (x : Fin (S n)) -> (e' : Expr env t') -> (e : Expr env t) -> subst x e' (incr x t' e) = e
substIncr x e' (Var y Refl) with (decEq x (incrFin y x))
  substIncr x e' (Var y Refl) | Yes eq = absurd (incrFinChanges y x (sym eq))
  substIncr x e' (Var y Refl) | No neq = ?substIncr_missingCase
substIncr x e' Con = Refl
substIncr x e' (App e1 e2) = rewrite substIncr x e' e1 in rewrite substIncr x e' e2 in Refl
substIncr x e' (Abs t1 e) = rewrite substIncr (FS x) (incr FZ t1 e') e in Refl

问题是substIncr证据的最后一个缺失案例。类型不会减少，因为subst只会在Var中的证明相同Refl时减少，而不是indexOfIncrFin x y env t'。现在，indexOfIncrFin是total，它总是返回Refl，但它的类型不仅仅是f x y = z;相反，它在平等的任一侧都有一个复杂的术语（index (incrFin y x) (insertAt x t env) = index y env）。因此，当我尝试通过with或case进行匹配时，它会抱怨index y env = index y env（Refl的类型）和index (incrFin y x) (insertAt x t' env) = index y env之间的类型不匹配（预期型）＆＃34;

我能想到的唯一另一件事就是将subst的定义更改为重写而不是Refl上的匹配，但是（a）有点丑，而且（b）让我陷入困境在某种rewrite__impl类型中，我理解的更少，而且也不会减少。

有关如何解决此问题的任何想法？

在伊德里斯，如何证明一个非平凡的平等是Refl？

0 个答案: