Using subst in an application would screw up type of the result

Question

I have a definition with the following type:

insert : ∀ {n} → (i : Fin (suc n)) → ∀ t → Env n → Env (suc n)
weaken : ∀ {t t₀ n} {Γ : Env n} → (i : Fin (suc n)) → (e : Γ ⊢ t₀) → (insert i t Γ) ⊢ t₀

Given two environments Γ : Env n and Γ′ : Env n′, and a pointer to a position in the second one, i : Fin (suc n), I would like to weaken an e : (Γ′ ++ Γ) ⊢ t₀.

In theory, this should be easy by using something like

let i′ = raise n′ i
weaken {t} i′ e : insert i′ t (Γ′ ++ Γ) ⊢ t₀

However, in practice it doesn't work out so nicely, because the typechecker is not convinced that raise n′ i has type Fin (suc _) (required by weaken):

(n′ + suc n) != (suc (_n_550 i e)) of type ℕ when checking that the expression i′ has type Fin (suc (_n_550 i e))

My problem is, I could use something like +-suc : ∀ n′ n → n′ + suc n ≡ suc (n′ + n) to substitute the type of i′, but then the resulting type from weaken i′ e will not have the form insert i′ t (Γ′ ++ Γ) ⊢ t₀.

Answer 1

Given two environments Γ : Env n and Γ′ : Env n′

Those are contexts.

It should be possible to change the type of insert to

data Bound : ℕ -> Set where
  zero : ∀ {n} -> Bound n
  suc  : ∀ {n} -> Bound n -> Bound (suc n)

insert : ∀ {n} → (i : Bound n) → ∀ t → Env n → Env (suc n)

without changing the body of the function.

You can write a version of raise that raises under suc:

raise′ : ∀ {m} n → Fin (suc m) → Fin (suc (n + m))
raise′ zero    i = i
raise′ (suc n) i = suc (raise′ n i)

But the actual solution is to rename terms using either functions:

Ren : Con -> Con -> Set
Ren Γ Δ = ∀ {σ} -> σ ∈ Γ -> σ ∈ Δ

keepʳ : ∀ {Γ Δ σ} -> Ren Γ Δ -> Ren (Γ ▻ σ) (Δ ▻ σ)
keepʳ r  vz    = vz
keepʳ r (vs v) = vs (r v)

ren : ∀ {Γ Δ σ} -> Ren Γ Δ -> Γ ⊢ σ -> Δ ⊢ σ
ren r (var v) = var (r v)
ren r (ƛ b  ) = ƛ (ren (keepʳ r) b)
ren r (f · x) = ren r f · ren r x

or order preserving embeddings.