From OGS Require Import Prelude.
From OGS.Utils Require Import Psh Rel.
From OGS.Ctx Require Import All Ctx Covering Subset.
From OGS.ITree Require Import Event ITree Eq Delay Structure Properties.
From OGS.OGS Require Import Soundness.
Set Equations Transparent.

Inductive pre_ty : Type :=
| Zer : pre_ty
| One : pre_ty
| Prod : pre_ty -> pre_ty -> pre_ty
| Sum : pre_ty -> pre_ty -> pre_ty
| Arr : pre_ty -> pre_ty -> pre_ty
.

Notation "`0" := (Zer) : ty_scope.
Notation "`1" := (One) : ty_scope.
Notation "A `× B" := (Prod A B) (at level 40) : ty_scope.
Notation "A `+ B" := (Sum A B) (at level 40) : ty_scope.
Notation "A `→ B" := (Arr A B) (at level 40) : ty_scope .

Variant ty : Type :=
| LTy : pre_ty -> ty
| RTy : pre_ty -> ty
.
Derive NoConfusion for ty.
Bind Scope ty_scope with ty.
#[global] Coercion LTy : pre_ty >-> ty.
#[global] Notation "↑ t" := (LTy t) (at level 5) : ty_scope .
#[global] Notation "¬ t" := (RTy t) (at level 5) : ty_scope .
Open Scope ty_scope.

Equations t_neg : ty -> ty :=
  t_neg ↑a := ¬a ;
  t_neg ¬a := ↑a .
Notation "a †" := (t_neg a) (at level 5) : ty_scope.

Definition t_ctx : Type := ctx ty.
Bind Scope ctx_scope with t_ctx.

Inductive term : t_ctx -> ty -> Type :=
| Val {Γ A} : whn Γ A -> term Γ ↑A
| Mu {Γ A} : state (Γ ▶ₓ ¬A) -> term Γ ↑A

| VarR {Γ A} : Γ ∋ ¬A -> term Γ ¬A
| MuT {Γ A} : state (Γ ▶ₓ ↑A) -> term Γ ¬A

| Boom {Γ} : term Γ ¬`0
| Case {Γ A B} : state (Γ ▶ₓ ↑A) -> state (Γ ▶ₓ ↑B) -> term Γ ¬(A `+ B)

| Fst {Γ A B} : term Γ ¬A -> term Γ ¬(A `× B)
| Snd {Γ A B} : term Γ ¬B -> term Γ ¬(A `× B)
| App {Γ A B} : whn Γ A -> term Γ ¬B -> term Γ ¬(A `→ B)

with whn : t_ctx -> pre_ty -> Type :=
| VarL {Γ A} : Γ ∋ ↑A -> whn Γ A

| Inl {Γ A B} : whn Γ A -> whn Γ (A `+ B)
| Inr {Γ A B} : whn Γ B -> whn Γ (A `+ B)

| Tt {Γ} : whn Γ `1
| Pair {Γ A B} : state (Γ ▶ₓ ¬A) -> state (Γ ▶ₓ ¬B) -> whn Γ (A `× B)
| Lam {Γ A B} : state (Γ ▶ₓ ↑(A `→ B) ▶ₓ ↑A ▶ₓ ¬B) -> whn Γ (A `→ B)

with state : t_ctx -> Type :=
| Cut {Γ A} : term Γ ↑A -> term Γ ¬A -> state Γ
.

Definition Cut' {Γ A} : term Γ A -> term Γ A† -> state Γ
  := match A with
     | ↑_ => fun x y => Cut x y
     | ¬_ => fun x y => Cut y x
     end .

Equations val : t_ctx -> ty -> Type :=
  val Γ ↑A := whn Γ A ;
  val Γ ¬A := term Γ ¬A .

Equations Var Γ A : Γ ∋ A -> val Γ A :=
  Var _ ↑_ i := VarL i ;
  Var _ ¬_ i := VarR i .
Arguments Var {Γ} [A] i.

Equations t_of_v Γ A : val Γ A -> term Γ A :=
  t_of_v _ ↑_ v := Val v ;
  t_of_v _ ¬_ k := k .
Arguments t_of_v [Γ A] v.
Coercion t_of_v : val >-> term.

Equations t_rename : term ⇒₁ ⟦ c_var , term ⟧₁ :=
  t_rename _ _ (Mu c)     _ f := Mu (s_rename _ c _ (r_shift1 f)) ;
  t_rename _ _ (Val v)    _ f := Val (w_rename _ _ v _ f) ;
  t_rename _ _ (VarR i)   _ f := VarR (f _ i) ;
  t_rename _ _ (MuT c)    _ f := MuT (s_rename _ c _ (r_shift1 f)) ;
  t_rename _ _ (Boom)     _ f := Boom ;
  t_rename _ _ (App u k)  _ f := App (w_rename _ _ u _ f) (t_rename _ _ k _ f) ;
  t_rename _ _ (Fst k)    _ f := Fst (t_rename _ _ k _ f) ;
  t_rename _ _ (Snd k)    _ f := Snd (t_rename _ _ k _ f) ;
  t_rename _ _ (Case u v) _ f :=
    Case (s_rename _ u _ (r_shift1 f))
         (s_rename _ v _ (r_shift1 f))
with w_rename : whn ⇒₁ ⟦ c_var , val ⟧₁ :=
  w_rename _ _ (VarL i)   _ f := VarL (f _ i) ;
  w_rename _ _ (Tt)       _ f := Tt ;
  w_rename _ _ (Lam u)    _ f := Lam (s_rename _ u _ (r_shift3 f)) ;
  w_rename _ _ (Pair u v) _ f :=
    Pair (s_rename _ u _ (r_shift1 f))
         (s_rename _ v _ (r_shift1 f)) ;
  w_rename _ _ (Inl u)    _ f := Inl (w_rename _ _ u _ f) ;
  w_rename _ _ (Inr u)    _ f := Inr (w_rename _ _ u _ f)
with s_rename : state ⇒₀ ⟦ c_var , state ⟧₀ :=
   s_rename _ (Cut v k) _ f := Cut (t_rename _ _ v _ f) (t_rename _ _ k _ f) .

Equations v_rename : val ⇒₁ ⟦ c_var , val ⟧₁ :=
  v_rename _ ↑_ v _ f := w_rename _ _ v _ f ;
  v_rename _ ¬_ k _ f := t_rename _ _ k _ f .

Notation "t ₜ⊛ᵣ r" := (t_rename _ _ t _ r%asgn) (at level 14).
Notation "w `ᵥ⊛ᵣ r" := (w_rename _ _ w _ r%asgn) (at level 14).
Notation "v ᵥ⊛ᵣ r" := (v_rename _ _ v _ r%asgn) (at level 14).
Notation "s ₛ⊛ᵣ r" := (s_rename _ s _ r%asgn) (at level 14).

Definition a_ren {Γ1 Γ2 Γ3} : Γ1 =[val]> Γ2 -> Γ2 ⊆ Γ3 -> Γ1 =[val]> Γ3 :=
  fun f g _ i => v_rename _ _ (f _ i) _ g .
Arguments a_ren {_ _ _} _ _ _ _ /.
Notation "a ⊛ᵣ r" := (a_ren a r%asgn) (at level 14) : asgn_scope.

Definition t_shift1 {Γ A} : term Γ  ⇒ᵢ term (Γ ▶ₓ A) := fun _ t => t ₜ⊛ᵣ r_pop.
Definition w_shift1 {Γ A} : whn Γ   ⇒ᵢ whn (Γ ▶ₓ A)  := fun _ w => w `ᵥ⊛ᵣ r_pop.
Definition s_shift1 {Γ A} : state Γ -> state (Γ ▶ₓ A) := fun s => s ₛ⊛ᵣ r_pop.
Definition v_shift1 {Γ A} : val Γ   ⇒ᵢ val (Γ ▶ₓ A)  := fun _ v => v ᵥ⊛ᵣ r_pop.
Definition v_shift3 {Γ A B C} : val Γ ⇒ᵢ val (Γ ▶ₓ A ▶ₓ B ▶ₓ C)
  := fun _ v => v ᵥ⊛ᵣ (r_pop ᵣ⊛ r_pop ᵣ⊛ r_pop).
Definition a_shift1 {Γ Δ} [A] (a : Γ =[val]> Δ) : (Γ ▶ₓ A) =[val]> (Δ ▶ₓ A)
  := [ fun _ i => v_shift1 _ (a _ i) ,ₓ Var top ].
Definition a_shift3 {Γ Δ} [A B C] (a : Γ =[val]> Δ)
  : (Γ ▶ₓ A ▶ₓ B ▶ₓ C) =[val]> (Δ ▶ₓ A ▶ₓ B ▶ₓ C)
  := [ [ [ fun _ i => v_shift3 _ (a _ i) ,ₓ
           Var (pop (pop top)) ] ,ₓ
         Var (pop top) ] ,ₓ
       Var top ].

Equations t_subst : term ⇒₁ ⟦ val , term ⟧₁ :=
  t_subst _ _ (Mu c)     _ f := Mu (s_subst _ c _ (a_shift1 f)) ;
  t_subst _ _ (Val v)    _ f := Val (w_subst _ _ v _ f) ;
  t_subst _ _ (VarR i)   _ f := f _ i ;
  t_subst _ _ (MuT c)    _ f := MuT (s_subst _ c _ (a_shift1 f)) ;
  t_subst _ _ (Boom)     _ f := Boom ;
  t_subst _ _ (App u k)  _ f := App (w_subst _ _ u _ f) (t_subst _ _ k _ f) ;
  t_subst _ _ (Fst k)    _ f := Fst (t_subst _ _ k _ f) ;
  t_subst _ _ (Snd k)    _ f := Snd (t_subst _ _ k _ f) ;
  t_subst _ _ (Case u v) _ f :=
    Case (s_subst _ u _ (a_shift1 f))
          (s_subst _ v _ (a_shift1 f))
with w_subst : forall Γ A, whn Γ A -> forall Δ, Γ =[val]> Δ -> whn Δ A :=
  w_subst _ _ (VarL i)   _ f := f _ i ;
  w_subst _ _ (Tt)       _ f := Tt ;
  w_subst _ _ (Lam u)    _ f := Lam (s_subst _ u _ (a_shift3 f)) ;
  w_subst _ _ (Pair u v) _ f := Pair (s_subst _ u _ (a_shift1 f))
                                     (s_subst _ v _ (a_shift1 f)) ;
  w_subst _ _ (Inl u)    _ f := Inl (w_subst _ _ u _ f) ;
  w_subst _ _ (Inr u)    _ f := Inr (w_subst _ _ u _ f)
with s_subst : state ⇒₀ ⟦ val , state ⟧₀ :=
   s_subst _ (Cut v k) _ f := Cut (t_subst _ _ v _ f) (t_subst _ _ k _ f) .

Notation "t `ₜ⊛ a" := (t_subst _ _ t _ a%asgn) (at level 30).
Notation "w `ᵥ⊛ a" := (w_subst _ _ w _ a%asgn) (at level 30).

Equations v_subst : val ⇒₁ ⟦ val , val ⟧₁ :=
  v_subst _ ↑_ v _ f := v `ᵥ⊛ f ;
  v_subst _ ¬_ k _ f := k `ₜ⊛ f .

#[global] Instance val_monoid : subst_monoid val :=
  {| v_var := @Var ; v_sub := v_subst |} .
#[global] Instance state_module : subst_module val state :=
  {| c_sub := s_subst |} .

Definition asgn1 {Γ A} (v : val Γ A) : (Γ ▶ₓ A) =[val]> Γ
  := [ Var ,ₓ v ] .
Definition asgn3 {Γ A B C} (v1 : val Γ A) (v2 : val Γ B) (v3 : val Γ C)
  : (Γ ▶ₓ A ▶ₓ B ▶ₓ C) =[val]> Γ
  := [ [ [ Var ,ₓ v1 ] ,ₓ v2 ] ,ₓ v3 ].
Arguments asgn1 {_ _} & _.
Arguments asgn3 {_ _ _ _} & _ _.

Notation "₁[ v ]" := (asgn1 v).
Notation "₃[ v1 , v2 , v3 ]" := (asgn3 v1 v2 v3).

(*
Variant forcing0 (Γ : t_ctx) : pre_ty -> Type :=
| FBoom : forcing0 Γ Zer
| FApp {a b} : whn Γ a -> term Γ ¬b -> forcing0 Γ (a `→ b)
| FFst {a b} : term Γ ¬a -> forcing0 Γ (a `× b)
| FSnd {a b} : term Γ ¬b -> forcing0 Γ (a `× b)
| FCase {a b} : state (Γ ▶ₓ ↑a) -> state (Γ ▶ₓ ↑b) -> forcing0 Γ (a `+ b)
.
Arguments FBoom {Γ}.
Arguments FApp {Γ a b}.
Arguments FFst {Γ a b}.
Arguments FSnd {Γ a b}.
Arguments FCase {Γ a b}.

Equations f0_subst {Γ Δ} : Γ =[val]> Δ -> forcing0 Γ ⇒ᵢ forcing0 Δ :=
  f0_subst f a (FBoom)        := FBoom ;
  f0_subst f a (FApp v k)     := FApp (w_subst f _ v) (t_subst f _ k) ;
  f0_subst f a (FFst k)       := FFst (t_subst f _ k) ;
  f0_subst f a (FSnd k)       := FSnd (t_subst f _ k) ;
  f0_subst f a (FCase s1 s2) := FCase (s_subst (a_shift1 f) s1) (s_subst (a_shift1 f) s2) .

Equations forcing : t_ctx -> ty -> Type :=
  forcing Γ (t+ a) := whn Γ a ;
  forcing Γ (t- a) := forcing0 Γ a .

Equations f_subst {Γ Δ} : Γ =[val]> Δ -> forcing Γ ⇒ᵢ forcing Δ :=
  f_subst s (t+ a) v := w_subst s a v ;
  f_subst s (t- a) f := f0_subst s a f .
*)

Equations is_neg_pre : pre_ty -> SProp :=
  is_neg_pre `0       := sEmpty ;
  is_neg_pre `1       := sUnit ;
  is_neg_pre (_ `× _) := sUnit ;
  is_neg_pre (_ `+ _) := sEmpty ;
  is_neg_pre (_ `→ _) := sUnit .

Equations is_neg : ty -> SProp :=
  is_neg ↑a := is_neg_pre a ;
  is_neg ¬a := sUnit .

Definition neg_ty : Type := sigS is_neg.
Definition neg_coe : neg_ty -> ty := sub_elt.
Global Coercion neg_coe : neg_ty >-> ty.

Definition neg_ctx : Type := ctxS ty t_ctx is_neg.
Definition neg_c_coe : neg_ctx -> ctx ty := sub_elt.
Global Coercion neg_c_coe : neg_ctx >-> ctx.

Bind Scope ctx_scope with neg_ctx.
Bind Scope ctx_scope with ctx.

Inductive pat : ty -> Type :=
| PTt : pat ↑`1
| PPair {a b} : pat ↑(a `× b)
| PInl {a b} : pat ↑a -> pat ↑(a `+ b)
| PInr {a b} : pat ↑b -> pat ↑(a `+ b)
| PLam {a b} : pat ↑(a `→ b)
| PFst {a b} : pat ¬(a `× b)
| PSnd {a b} : pat ¬(a `× b)
| PApp {a b} : pat ↑a -> pat ¬(a `→ b)
.

Equations pat_dom {t} : pat t -> neg_ctx :=
  pat_dom (PInl u) := pat_dom u ;
  pat_dom (PInr u) := pat_dom u ;
  pat_dom (PTt) := ∅ₛ ▶ₛ {| sub_elt := ↑`1 ; sub_prf := stt |} ;
  pat_dom (@PLam a b) := ∅ₛ ▶ₛ {| sub_elt := ↑(a `→ b) ; sub_prf := stt |} ;
  pat_dom (@PPair a b) := ∅ₛ ▶ₛ {| sub_elt := ↑(a `× b) ; sub_prf := stt |} ;
  pat_dom (@PApp a b v) := pat_dom v ▶ₛ {| sub_elt := ¬b ; sub_prf := stt |} ;
  pat_dom (@PFst a b) := ∅ₛ ▶ₛ {| sub_elt := ¬a ; sub_prf := stt |} ;
  pat_dom (@PSnd a b) := ∅ₛ ▶ₛ {| sub_elt := ¬b ; sub_prf := stt |} .

Definition op_pat : Oper ty neg_ctx :=
  {| o_op a := pat a ; o_dom _ p := (pat_dom p) |} .

Definition op_copat : Oper ty neg_ctx :=
  {| o_op a := pat (t_neg a) ; o_dom _ p := (pat_dom p) |} .

Definition bare_copat := op_copat∙ .

Equations v_of_p {A} (p : pat A) : val (pat_dom p) A :=
  v_of_p (PInl u) := Inl (v_of_p u) ;
  v_of_p (PInr u) := Inr (v_of_p u) ;
  v_of_p (PTt) := VarL top ;
  v_of_p (PLam) := VarL top ;
  v_of_p (PPair) := VarL top ;
  v_of_p (PApp v) := App (v_shift1 _ (v_of_p v)) (VarR top) ;
  v_of_p (PFst) := Fst (VarR top) ;
  v_of_p (PSnd) := Snd (VarR top) .
Coercion v_of_p : pat >-> val.

Definition elim_var_zer {A : Type} {Γ : neg_ctx} (i : Γ ∋ ↑ `0) : A
  := match s_prf i with end .
Definition elim_var_sum {A : Type} {Γ : neg_ctx} {s t} (i : Γ ∋ ↑ (s `+ t)) : A
  := match s_prf i with end .

Equations p_of_w {Γ : neg_ctx} a : whn Γ a -> pat ↑a :=
  p_of_w (`0)     (VarL i) := elim_var_zer i ;
  p_of_w (a `+ b) (VarL i) := elim_var_sum i ;
  p_of_w (a `+ b) (Inl v)  := PInl (p_of_w _ v) ;
  p_of_w (a `+ b) (Inr v)  := PInr (p_of_w _ v) ;
  p_of_w (`1)     _        := PTt ;
  p_of_w (a `× b) _        := PPair ;
  p_of_w (a `→ b) _        := PLam .

Equations p_dom_of_w {Γ : neg_ctx} a (v : whn Γ a) : pat_dom (p_of_w a v) =[val]> Γ :=
  p_dom_of_w (`0)     (VarL i) := elim_var_zer i ;
  p_dom_of_w (a `+ b) (VarL i) := elim_var_sum i ;
  p_dom_of_w (a `+ b) (Inl v)  := p_dom_of_w a v ;
  p_dom_of_w (a `+ b) (Inr v)  := p_dom_of_w b v ;
  p_dom_of_w (`1)     v        := [ ! ,ₓ v ] ;
  p_dom_of_w (a `→ b) v        := [ ! ,ₓ v ] ;
  p_dom_of_w (a `× b) v        := [ ! ,ₓ v ] .

Program Definition w_split {Γ : neg_ctx} a (v : whn Γ a) : (op_copat # val) Γ ¬a
  := p_of_w _ v ⦇ p_dom_of_w _ v ⦈ .

Definition L_nf : Fam₀ ty neg_ctx := c_var ∥ₛ (op_copat # val ).

(*
Definition n_rename {Γ Δ : neg_ctx} : Γ ⊆ Δ -> L_nf Γ -> L_nf Δ
  := fun r n => r _ (nf_var n) ⋅ nf_obs n ⦇ a_ren r (nf_args n) ⦈.
*)

(*
Definition nf0_eq {Γ a} : relation (nf0 Γ a) :=
  fun a b => exists H : projT1 a = projT1 b, rew H in projT2 a ≡ₐ projT2 b .

Definition nf_eq {Γ} : relation (nf Γ) :=
  fun a b => exists H : projT1 a = projT1 b,
      (rew H in fst (projT2 a) = fst (projT2 b)) /\ (nf0_eq (rew H in snd (projT2 a)) (snd (projT2 b))).

#[global] Instance nf0_eq_rfl {Γ t} : Reflexive (@nf0_eq Γ t) .
  intros [ m a ]; unshelve econstructor; auto.
Qed.

#[global] Instance nf0_eq_sym {Γ t} : Symmetric (@nf0_eq Γ t) .
  intros [ m1 a1 ] [ m2 a2 ] [ p q ]; unshelve econstructor; cbn in *.
  - now symmetry.
  - revert a1 q ; rewrite p; intros a1 q.
    now symmetry.
Qed.

#[global] Instance nf0_eq_tra {Γ t} : Transitive (@nf0_eq Γ t) .
  intros [ m1 a1 ] [ m2 a2 ] [ m3 a3 ] [ p1 q1 ] [ p2 q2 ]; unshelve econstructor; cbn in *.
  - now transitivity m2.
  - transitivity (rew [fun p : pat (t_neg t) => pat_dom p =[ val ]> Γ] p2 in a2); auto.
    now rewrite <- p2.
Qed.

#[global] Instance nf_eq_rfl {Γ} : Reflexiveᵢ (fun _ : T1 => @nf_eq Γ) .
  intros _ [ x [ i n ] ].
  unshelve econstructor; auto.
Qed.

#[global] Instance nf_eq_sym {Γ} : Symmetricᵢ (fun _ : T1 => @nf_eq Γ) .
  intros _ [ x1 [ i1 n1 ] ] [ x2 [ i2 n2 ] ] [ p [ q1 q2 ] ].
  unshelve econstructor; [ | split ]; cbn in *.
  - now symmetry.
  - revert i1 q1; rewrite p; intros i1 q1; now symmetry.
  - revert n1 q2; rewrite p; intros n1 q2; now symmetry.
Qed.

#[global] Instance nf_eq_tra {Γ} : Transitiveᵢ (fun _ : T1 => @nf_eq Γ) .
  intros _ [ x1 [ i1 n1 ] ] [ x2 [ i2 n2 ] ] [ x3 [ i3 n3 ] ] [ p1 [ q1 r1 ] ] [ p2 [ q2 r2 ] ].
  unshelve econstructor; [ | split ]; cbn in *.
  - now transitivity x2.
  - transitivity (rew [has Γ] p2 in i2); auto.
    now rewrite <- p2.
  - transitivity (rew [nf0 Γ] p2 in n2); auto.
    now rewrite <- p2.
Qed.

Definition comp_eq {Γ} : relation (delay (nf Γ)) :=
  it_eq (fun _ : T1 => nf_eq) (i := T1_0) .
Notation "u ≋ v" := (comp_eq u v) (at level 40) .

Definition pat_of_nf : nf ⇒ᵢ pat' :=
  fun Γ u => (projT1 u ,' (fst (projT2 u) , projT1 (snd (projT2 u)))) .
*)

Program Definition app_nf {Γ : neg_ctx} {a b} (i : Γ ∋ ↑(a `→ b))
  (v : whn Γ a) (k : term Γ ¬b) : L_nf Γ
  := i ⋅ PApp (p_of_w _ v) ⦇ [ p_dom_of_w _ v ,ₓ (k : val _ ¬_) ] ⦈ .

Program Definition fst_nf {Γ : neg_ctx} {a b} (i : Γ ∋ ↑(a `× b))
  (k : term Γ ¬a) : L_nf Γ
  := i ⋅ PFst ⦇ [ ! ,ₓ (k : val _ ¬_) ] ⦈ .

Program Definition snd_nf {Γ : neg_ctx} {a b} (i : Γ ∋ ↑(a `× b))
  (k : term Γ ¬b) : L_nf Γ
  := i ⋅ PSnd ⦇ [ ! ,ₓ (k : val _ ¬_) ] ⦈ .

Equations eval_aux {Γ : neg_ctx} : state Γ -> (state Γ + L_nf Γ) :=
  eval_aux (Cut (Mu s)           (k))        := inl (s ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut (Val v)          (MuT s))    := inl (s ₜ⊛ ₁[ v ]) ;

  eval_aux (Cut (Val v)          (VarR i))   := inr (s_var_upg i ⋅ w_split _ v) ;

  eval_aux (Cut (Val (VarL i))   (Boom))     := elim_var_zer i ;
  eval_aux (Cut (Val (VarL i))   (Case s t)) := elim_var_sum i ;

  eval_aux (Cut (Val (VarL i))   (App v k))  := inr (app_nf i v k) ;
  eval_aux (Cut (Val (VarL i))   (Fst k))    := inr (fst_nf i k) ;
  eval_aux (Cut (Val (VarL i))   (Snd k))    := inr (snd_nf i k) ;


  eval_aux (Cut (Val (Lam s))    (App v k))  := inl (s ₜ⊛ ₃[ Lam s , v , k ]) ;
  eval_aux (Cut (Val (Pair s t)) (Fst k))    := inl (s ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut (Val (Pair s t)) (Snd k))    := inl (t ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut (Val (Inl u))    (Case s t)) := inl (s ₜ⊛ ₁[ u ]) ;
  eval_aux (Cut (Val (Inr u))    (Case s t)) := inl (t ₜ⊛ ₁[ u ]) .

Definition eval {Γ : neg_ctx} : state Γ -> delay (L_nf Γ)
  := iter_delay (fun c => Ret' (eval_aux c)).

(*
Definition refold {Γ : neg_ctx} (p : nf Γ)
  : (Γ ∋ (projT1 p) * val Γ (t_neg (projT1 p)))%type.
destruct p as [x [i [ p s ]]]; cbn in *.
exact (i , v_subst s _ (v_of_p p)).
Defined.
*)

Definition p_app {Γ A} (v : val Γ A) (m : pat A†) (e : pat_dom m =[val]> Γ) : state Γ
  := Cut' v (m `ₜ⊛ e) .

(*
Definition emb {Γ} (m : pat' Γ) : state (Γ +▶ₓ pat_dom' Γ m) .
  destruct m as [a [i v]]; cbn in *.
  destruct a.
  - refine (Cut _ _).
    + refine (Val (VarL (r_concat_l _ i))).
    + refine (t_rename r_concat_r _ (v_of_p v)).
  - refine (Cut _ _).
    + refine (Val (v_rename r_concat_r _ (v_of_p v))).
    + refine (VarR (r_concat_l _ i)).
Defined.
*)

Scheme term_mut := Induction for term Sort Prop
  with whn_mut := Induction for whn Sort Prop
  with state_mut := Induction for state Sort Prop.

Record syn_ind_args (Pt : forall Γ A, term Γ A -> Prop)
                    (Pv : forall Γ A, whn Γ A -> Prop)
                    (Ps : forall Γ, state Γ -> Prop) :=
{
  ind_s_mu : forall Γ A s, Ps _ s -> Pt Γ ↑A (Mu s) ;
  ind_s_val : forall Γ A v, Pv _ _ v -> Pt Γ ↑A (Val v) ;
  ind_s_varn : forall Γ A i, Pt Γ ¬A (VarR i) ;
  ind_s_mut : forall Γ A s, Ps _ s -> Pt Γ ¬A (MuT s) ;
  ind_s_zer : forall Γ, Pt Γ ¬`0 Boom ;
  ind_s_app : forall Γ A B, forall v, Pv _ _ v -> forall k, Pt _ _ k -> Pt Γ ¬(A `→ B) (App v k) ;
  ind_s_fst : forall Γ A B, forall k, Pt _ _ k -> Pt Γ ¬(A `× B) (Fst k) ;
  ind_s_snd : forall Γ A B, forall k, Pt _ _ k -> Pt Γ ¬(A `× B) (Snd k) ;
  ind_s_match : forall Γ A B, forall s, Ps _ s -> forall t, Ps _ t -> Pt Γ ¬(A `+ B) (Case s t) ;
  ind_s_varp : forall Γ A i, Pv Γ A (VarL i) ;
  ind_s_inl : forall Γ A B v, Pv _ _ v -> Pv Γ (A `+ B) (Inl v) ;
  ind_s_inr : forall Γ A B v, Pv _ _ v -> Pv Γ (A `+ B) (Inr v) ;
  ind_s_onei : forall Γ, Pv Γ `1 Tt ;
  ind_s_lam : forall Γ A B s, Ps _ s -> Pv Γ (A `→ B) (Lam s) ;
  ind_s_pair : forall Γ A B, forall s, Ps _ s -> forall t, Ps _ t -> Pv Γ (A `× B) (Pair s t) ;
  ind_s_cut : forall Γ A, forall u, Pt _ _ u -> forall v, Pt _ _ v -> Ps Γ (@Cut _ A u v)
} .

Lemma term_ind_mut Pt Pv Ps (arg : syn_ind_args Pt Pv Ps) Γ A u : Pt Γ A u.
Pt: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
Pv: forall (Γ : t_ctx) (A : pre_ty), whn Γ A -> Prop
Ps: forall Γ : t_ctx, state Γ -> Prop
arg: syn_ind_args Pt Pv Ps
Γ: t_ctx
A: ty
u: term Γ A
Pt Γ A u
  destruct arg; now apply (term_mut Pt Pv Ps).
Qed.

Lemma whn_ind_mut Pt Pv Ps (arg : syn_ind_args Pt Pv Ps) Γ A v : Pv Γ A v.
Pt: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
Pv: forall (Γ : t_ctx) (A : pre_ty), whn Γ A -> Prop
Ps: forall Γ : t_ctx, state Γ -> Prop
arg: syn_ind_args Pt Pv Ps
Γ: t_ctx
A: pre_ty
v: whn Γ A
Pv Γ A v
  destruct arg; now apply (whn_mut Pt Pv Ps).
Qed.

Lemma state_ind_mut Pt Pv Ps (arg : syn_ind_args Pt Pv Ps) Γ s : Ps Γ s.
Pt: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
Pv: forall (Γ : t_ctx) (A : pre_ty), whn Γ A -> Prop
Ps: forall Γ : t_ctx, state Γ -> Prop
arg: syn_ind_args Pt Pv Ps
Γ: t_ctx
s: state Γ
Ps Γ s
  destruct arg; now apply (state_mut Pt Pv Ps).
Qed.

Definition t_ren_proper_P Γ A (t : term Γ A) : Prop :=
  forall Δ (f1 f2 : Γ ⊆ Δ), f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2 .
Definition w_ren_proper_P Γ A (v : whn Γ A) : Prop :=
  forall Δ (f1 f2 : Γ ⊆ Δ), f1 ≡ₐ f2 -> v `ᵥ⊛ᵣ f1 = v `ᵥ⊛ᵣ f2 .
Definition s_ren_proper_P Γ (s : state Γ) : Prop :=
  forall Δ (f1 f2 : Γ ⊆ Δ), f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2 .
Lemma ren_proper_prf : syn_ind_args t_ren_proper_P w_ren_proper_P s_ren_proper_P.
syn_ind_args t_ren_proper_P w_ren_proper_P
  s_ren_proper_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_ren_proper_P (Γ ▶ₓ ¬ A) s ->
t_ren_proper_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_ren_proper_P Γ A v -> t_ren_proper_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_ren_proper_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_ren_proper_P (Γ ▶ₓ ↑ A) s ->
t_ren_proper_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_ren_proper_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_proper_P Γ A v ->
forall k : term Γ ¬ B,
t_ren_proper_P Γ ¬ B k ->
t_ren_proper_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_ren_proper_P Γ ¬ A k ->
t_ren_proper_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_ren_proper_P Γ ¬ B k ->
t_ren_proper_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_ren_proper_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_ren_proper_P (Γ ▶ₓ ↑ B) t ->
t_ren_proper_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_ren_proper_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_proper_P Γ A v ->
w_ren_proper_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_ren_proper_P Γ B v ->
w_ren_proper_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_ren_proper_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_ren_proper_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_ren_proper_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_ren_proper_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_ren_proper_P (Γ ▶ₓ ¬ B) t ->
w_ren_proper_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_ren_proper_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_ren_proper_P Γ ¬ A v -> s_ren_proper_P Γ (Cut u v)
  all: unfold t_ren_proper_P, w_ren_proper_P, s_ren_proper_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Mu s ₜ⊛ᵣ f1 = Mu s ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ᵣ f1 = v `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Val v ₜ⊛ᵣ f1 = Val v ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> VarR i ₜ⊛ᵣ f1 = VarR i ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> MuT s ₜ⊛ᵣ f1 = MuT s ₜ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Boom ₜ⊛ᵣ f1 = Boom ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ᵣ f1 = v `ᵥ⊛ᵣ f2) ->
forall k : term Γ ¬ B,
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> k ₜ⊛ᵣ f1 = k ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> App v k ₜ⊛ᵣ f1 = App v k ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> k ₜ⊛ᵣ f1 = k ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Fst k ₜ⊛ᵣ f1 = Fst k ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> k ₜ⊛ᵣ f1 = k ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Snd k ₜ⊛ᵣ f1 = Snd k ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
 f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Case s t ₜ⊛ᵣ f1 = Case s t ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> VarL i `ᵥ⊛ᵣ f1 = VarL i `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ᵣ f1 = v `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Inl v `ᵥ⊛ᵣ f1 = Inl v `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ᵣ f1 = v `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Inr v `ᵥ⊛ᵣ f1 = Inr v `ᵥ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Tt `ᵥ⊛ᵣ f1 = Tt `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Δ : t_ctx)
   (f1 f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Lam s `ᵥ⊛ᵣ f1 = Lam s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
 f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Pair s t `ᵥ⊛ᵣ f1 = Pair s t `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> u ₜ⊛ᵣ f1 = u ₜ⊛ᵣ f2) ->
forall v : term Γ ¬ A,
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> v ₜ⊛ᵣ f1 = v ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Cut u v ₛ⊛ᵣ f1 = Cut u v ₛ⊛ᵣ f2
  all: intros; cbn; f_equal; cbn; eauto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: pre_ty
i: Γ ∋ ¬ A
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
f1 ¬ A i = f2 ¬ A i
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
t ₛ⊛ᵣ r_shift1 f1 = t ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: pre_ty
i: Γ ∋ ↑ A
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
f1 ↑ A i = f2 ↑ A i
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift3 f1 = s ₛ⊛ᵣ r_shift3 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
t ₛ⊛ᵣ r_shift1 f1 = t ₛ⊛ᵣ r_shift1 f2
  all: try now apply H.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
t ₛ⊛ᵣ r_shift1 f1 = t ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift3 f1 = s ₛ⊛ᵣ r_shift3 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift1 f1 = s ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
t ₛ⊛ᵣ r_shift1 f1 = t ₛ⊛ᵣ r_shift1 f2
  all: first [ apply H | apply H0 | apply H1 | apply H2 ]; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift3 f1 ≡ₐ r_shift3 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) ⊆ Δ),
f1 ≡ₐ f2 -> t ₛ⊛ᵣ f1 = t ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H1: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
  all: first [ apply r_shift1_eq | apply r_shift3_eq ]; auto.
Qed.

#[global] Instance t_ren_eq {Γ a t Δ} : Proper (asgn_eq _ _ ==> eq) (t_rename Γ a t Δ).
Γ: t_ctx
a: ty
t: term Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (t_rename Γ a t Δ)
  intros f1 f2 H1; now apply (term_ind_mut _ _ _ ren_proper_prf).
Qed.

#[global] Instance w_ren_eq {Γ a v Δ} : Proper (asgn_eq _ _ ==> eq) (w_rename Γ a v Δ).
Γ: t_ctx
a: pre_ty
v: whn Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (w_rename Γ a v Δ)
  intros f1 f2 H1; now apply (whn_ind_mut _ _ _ ren_proper_prf).
Qed.

#[global] Instance s_ren_eq {Γ s Δ} : Proper (asgn_eq _ _ ==> eq) (s_rename Γ s Δ).
Γ: t_ctx
s: state Γ
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (s_rename Γ s Δ)
  intros f1 f2 H1; now apply (state_ind_mut _ _ _ ren_proper_prf).
Qed.

#[global] Instance v_ren_eq {Γ a v Δ} : Proper (asgn_eq _ _ ==> eq) (v_rename Γ a v Δ).
Γ: t_ctx
a: ty
v: val Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ a v Δ)
  destruct a.
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ ↑ p v Δ)
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ ¬ p v Δ)
  now apply w_ren_eq.
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ ¬ p v Δ)
  now apply t_ren_eq.
Qed.

#[global] Instance a_ren_eq {Γ1 Γ2 Γ3}
  : Proper (asgn_eq _ _ ==> asgn_eq _ _ ==> asgn_eq _ _) (@a_ren Γ1 Γ2 Γ3).
Γ1, Γ2, Γ3: t_ctx
Proper
  (asgn_eq Γ1 Γ2 ==> asgn_eq Γ2 Γ3 ==> asgn_eq Γ1 Γ3)
  a_ren
  intros r1 r2 H1 a1 a2 H2 ? i; cbn; now rewrite H1, (v_ren_eq _ _ H2).
Qed.

#[global] Instance a_shift1_eq {Γ Δ A} : Proper (asgn_eq _ _ ==> asgn_eq _ _) (@a_shift1 Γ Δ A).
Γ, Δ: t_ctx
A: ty
Proper (asgn_eq Γ Δ ==> asgn_eq (Γ ▶ₓ A) (Δ ▶ₓ A))
  (a_shift1 (A:=A))
  intros ? ? H ? h.
Γ, Δ: t_ctx
A: ty
x, y: Γ =[ val ]> Δ
H: x ≡ₐ y
a: ty
h: Γ ▶ₓ A ∋ a
a_shift1 x a h = a_shift1 y a h
  dependent elimination h; auto; cbn; now rewrite H.
Qed.

#[global] Instance a_shift3_eq {Γ Δ A B C}
  : Proper (asgn_eq _ _ ==> asgn_eq _ _) (@a_shift3 Γ Δ A B C).
Γ, Δ: t_ctx
A, B, C: ty
Proper
  (asgn_eq Γ Δ ==>
   asgn_eq (Γ ▶ₓ A ▶ₓ B ▶ₓ C) (Δ ▶ₓ A ▶ₓ B ▶ₓ C))
  (a_shift3 (C:=C))
  intros ? ? H ? v.
Γ, Δ: t_ctx
A, B, C: ty
x, y: Γ =[ val ]> Δ
H: x ≡ₐ y
a: ty
v: Γ ▶ₓ A ▶ₓ B ▶ₓ C ∋ a
a_shift3 x a v = a_shift3 y a v
  do 3 (dependent elimination v; auto).
Γ1: ctx ty
Δ: t_ctx
y2, y1, y0: ty
x, y: Γ1 =[ val ]> Δ
H: x ≡ₐ y
a: ty
v: var a Γ1
a_shift3 x a (pop (pop (pop v))) =
a_shift3 y a (pop (pop (pop v)))
  cbn; now rewrite H.
Qed.

Definition t_ren_ren_P Γ1 A (t : term Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
    (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2) .
Definition w_ren_ren_P Γ1 A (v : whn Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
    (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2) .
Definition s_ren_ren_P Γ1 (s : state Γ1) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
    (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2) .

Lemma ren_ren_prf : syn_ind_args t_ren_ren_P w_ren_ren_P s_ren_ren_P.
syn_ind_args t_ren_ren_P w_ren_ren_P s_ren_ren_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_ren_ren_P (Γ ▶ₓ ¬ A) s -> t_ren_ren_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_ren_ren_P Γ A v -> t_ren_ren_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_ren_ren_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_ren_ren_P (Γ ▶ₓ ↑ A) s -> t_ren_ren_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_ren_ren_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_ren_P Γ A v ->
forall k : term Γ ¬ B,
t_ren_ren_P Γ ¬ B k ->
t_ren_ren_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_ren_ren_P Γ ¬ A k ->
t_ren_ren_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_ren_ren_P Γ ¬ B k ->
t_ren_ren_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_ren_ren_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_ren_ren_P (Γ ▶ₓ ↑ B) t ->
t_ren_ren_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_ren_ren_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_ren_P Γ A v -> w_ren_ren_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_ren_ren_P Γ B v -> w_ren_ren_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_ren_ren_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_ren_ren_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_ren_ren_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_ren_ren_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_ren_ren_P (Γ ▶ₓ ¬ B) t ->
w_ren_ren_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_ren_ren_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_ren_ren_P Γ ¬ A v -> s_ren_ren_P Γ (Cut u v)
  all: unfold t_ren_ren_P, w_ren_ren_P, s_ren_ren_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Mu s ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Mu s ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Val v ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Val v ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(VarR i ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = VarR i ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(MuT s ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = MuT s ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Boom ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Boom ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall k : term Γ ¬ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = k ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(App v k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = App v k ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = k ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Fst k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Fst k ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = k ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Snd k ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Snd k ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Case s t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Case s t ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(VarL i `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = VarL i `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Inl v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Inl v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Inr v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Inr v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Tt `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Tt `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Lam s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Lam s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Pair s t `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Pair s t `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (u ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = u ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall v : term Γ ¬ A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (v ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = v ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Cut u v ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = Cut u v ₛ⊛ᵣ (f1 ᵣ⊛ f2)
  all: intros; cbn; f_equal; eauto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(t ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
t ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift3 f1) ₛ⊛ᵣ r_shift3 f2 =
s ₛ⊛ᵣ r_shift3 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = t ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(t ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
t ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
  all: first [ rewrite r_shift1_comp | rewrite r_shift3_comp ]; eauto.
Qed.

Lemma t_ren_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3) A (t : term Γ1 A)
  : (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2) .
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
A: ty
t: term Γ1 A
(t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply (term_ind_mut _ _ _ ren_ren_prf).
Qed.
Lemma w_ren_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3) A (v : whn Γ1 A)
  : (v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2) .
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
A: pre_ty
v: whn Γ1 A
(v `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply (whn_ind_mut _ _ _ ren_ren_prf).
Qed.
Lemma s_ren_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3) (s : state Γ1)
  : (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2) .
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
s: state Γ1
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply (state_ind_mut _ _ _ ren_ren_prf).
Qed.
Lemma v_ren_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 ⊆ Γ3) A (v : val Γ1 A)
  : (v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2) .
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
A: ty
v: val Γ1 A
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  destruct A.
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ↑ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply w_ren_ren.
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply t_ren_ren.
Qed.

Definition t_ren_id_l_P Γ A (t : term Γ A) : Prop := t ₜ⊛ᵣ r_id = t.
Definition w_ren_id_l_P Γ A (v : whn Γ A) : Prop := v `ᵥ⊛ᵣ r_id = v.
Definition s_ren_id_l_P Γ (s : state Γ) : Prop := s ₛ⊛ᵣ r_id  = s.

Lemma ren_id_l_prf : syn_ind_args t_ren_id_l_P w_ren_id_l_P s_ren_id_l_P.
syn_ind_args t_ren_id_l_P w_ren_id_l_P s_ren_id_l_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_ren_id_l_P (Γ ▶ₓ ¬ A) s -> t_ren_id_l_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_ren_id_l_P Γ A v -> t_ren_id_l_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_ren_id_l_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_ren_id_l_P (Γ ▶ₓ ↑ A) s ->
t_ren_id_l_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_ren_id_l_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_id_l_P Γ A v ->
forall k : term Γ ¬ B,
t_ren_id_l_P Γ ¬ B k ->
t_ren_id_l_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_ren_id_l_P Γ ¬ A k ->
t_ren_id_l_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_ren_id_l_P Γ ¬ B k ->
t_ren_id_l_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_ren_id_l_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_ren_id_l_P (Γ ▶ₓ ↑ B) t ->
t_ren_id_l_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_ren_id_l_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_id_l_P Γ A v -> w_ren_id_l_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_ren_id_l_P Γ B v -> w_ren_id_l_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_ren_id_l_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_ren_id_l_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_ren_id_l_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_ren_id_l_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_ren_id_l_P (Γ ▶ₓ ¬ B) t ->
w_ren_id_l_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_ren_id_l_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_ren_id_l_P Γ ¬ A v -> s_ren_id_l_P Γ (Cut u v)
  all: unfold t_ren_id_l_P, w_ren_id_l_P, s_ren_id_l_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s ₛ⊛ᵣ r_id = s -> Mu s ₜ⊛ᵣ r_id = Mu s
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
v `ᵥ⊛ᵣ r_id = v -> Val v ₜ⊛ᵣ r_id = Val v
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
VarR i ₜ⊛ᵣ r_id = VarR i
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s ₛ⊛ᵣ r_id = s -> MuT s ₜ⊛ᵣ r_id = MuT s
forall Γ : t_ctx, Boom ₜ⊛ᵣ r_id = Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
v `ᵥ⊛ᵣ r_id = v ->
forall k : term Γ ¬ B,
k ₜ⊛ᵣ r_id = k -> App v k ₜ⊛ᵣ r_id = App v k
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
k ₜ⊛ᵣ r_id = k -> Fst k ₜ⊛ᵣ r_id = Fst k
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
k ₜ⊛ᵣ r_id = k -> Snd k ₜ⊛ᵣ r_id = Snd k
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s ₛ⊛ᵣ r_id = s ->
forall t : state (Γ ▶ₓ ↑ B),
t ₛ⊛ᵣ r_id = t -> Case s t ₜ⊛ᵣ r_id = Case s t
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
VarL i `ᵥ⊛ᵣ r_id = VarL i
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
v `ᵥ⊛ᵣ r_id = v -> Inl v `ᵥ⊛ᵣ r_id = Inl v
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
v `ᵥ⊛ᵣ r_id = v -> Inr v `ᵥ⊛ᵣ r_id = Inr v
forall Γ : t_ctx, Tt `ᵥ⊛ᵣ r_id = Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s ₛ⊛ᵣ r_id = s -> Lam s `ᵥ⊛ᵣ r_id = Lam s
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s ₛ⊛ᵣ r_id = s ->
forall t : state (Γ ▶ₓ ¬ B),
t ₛ⊛ᵣ r_id = t -> Pair s t `ᵥ⊛ᵣ r_id = Pair s t
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
u ₜ⊛ᵣ r_id = u ->
forall v : term Γ ¬ A,
v ₜ⊛ᵣ r_id = v -> Cut u v ₛ⊛ᵣ r_id = Cut u v
  all: intros; cbn; f_equal; eauto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₛ⊛ᵣ r_id = s
t: state (Γ ▶ₓ ↑ B)
H0: t ₛ⊛ᵣ r_id = t
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₛ⊛ᵣ r_id = s
t: state (Γ ▶ₓ ↑ B)
H0: t ₛ⊛ᵣ r_id = t
t ₛ⊛ᵣ r_shift1 r_id = t
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift3 r_id = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₛ⊛ᵣ r_id = s
t: state (Γ ▶ₓ ¬ B)
H0: t ₛ⊛ᵣ r_id = t
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₛ⊛ᵣ r_id = s
t: state (Γ ▶ₓ ¬ B)
H0: t ₛ⊛ᵣ r_id = t
t ₛ⊛ᵣ r_shift1 r_id = t
  all: first [ rewrite r_shift1_id | rewrite r_shift3_id ]; eauto.
Qed.

Lemma t_ren_id_l {Γ} A (t : term Γ A) : t ₜ⊛ᵣ r_id = t.
Γ: t_ctx
A: ty
t: term Γ A
t ₜ⊛ᵣ r_id = t
  now apply (term_ind_mut _ _ _ ren_id_l_prf).
Qed.
Lemma w_ren_id_l {Γ} A (v : whn Γ A) : v `ᵥ⊛ᵣ r_id = v.
Γ: t_ctx
A: pre_ty
v: whn Γ A
v `ᵥ⊛ᵣ r_id = v
  now apply (whn_ind_mut _ _ _ ren_id_l_prf).
Qed.
Lemma s_ren_id_l {Γ} (s : state Γ) : s ₛ⊛ᵣ r_id  = s.
Γ: t_ctx
s: state Γ
s ₛ⊛ᵣ r_id = s
  now apply (state_ind_mut _ _ _ ren_id_l_prf).
Qed.
Lemma v_ren_id_l {Γ} A (v : val Γ A) : v ᵥ⊛ᵣ r_id = v.
Γ: t_ctx
A: ty
v: val Γ A
v ᵥ⊛ᵣ r_id = v
  destruct A.
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
v ᵥ⊛ᵣ r_id = v
  now apply w_ren_id_l.
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
v ᵥ⊛ᵣ r_id = v
  now apply t_ren_id_l.
Qed.

Lemma v_ren_id_r {Γ Δ} (f : Γ ⊆ Δ) A (i : Γ ∋ A) : (Var i) ᵥ⊛ᵣ f = Var (f _ i).
Γ, Δ: ctx ty
f: Γ ⊆ Δ
A: ty
i: Γ ∋ A
Var i ᵥ⊛ᵣ f = Var (f A i)
  now destruct A.
Qed.

Lemma a_shift1_id {Γ A} : @a_shift1 Γ Γ A Var ≡ₐ Var.
Γ: t_ctx
A: ty
a_shift1 Var ≡ₐ Var
  intros [ [] | [] ] i; dependent elimination i; auto.
Qed.

Lemma a_shift3_id {Γ A B C} : @a_shift3 Γ Γ A B C Var ≡ₐ Var.
Γ: t_ctx
A, B, C: ty
a_shift3 Var ≡ₐ Var
  intros ? v; cbn.
Γ: t_ctx
A, B, C, a: ty
v: Γ ▶ₓ A ▶ₓ B ▶ₓ C ∋ a
a_shift3 Var a v = Var v
  do 3 (dependent elimination v; cbn; auto).
Γ1: ctx ty
y1, y0, y, a: ty
v: var a Γ1
v_shift3 a (Var v) = Var (pop (pop (pop v)))
  now destruct a.
Qed.

Arguments Var : simpl never.
Lemma a_shift1_ren_r {Γ1 Γ2 Γ3 A} (f1 : Γ1 =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3)
      : a_shift1 (A:=A) (f1 ⊛ᵣ f2) ≡ₐ a_shift1 f1 ⊛ᵣ r_shift1 f2 .
Γ1, Γ2, Γ3: t_ctx
A: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a_shift1 (f1 ⊛ᵣ f2) ≡ₐ a_shift1 f1 ⊛ᵣ r_shift1 f2
  intros ? h; dependent elimination h; cbn.
Γ: ctx ty
Γ2, Γ3: t_ctx
a: ty
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Var top = Var top ᵥ⊛ᵣ r_shift1 f2
Γ0: ctx ty
Γ2, Γ3: t_ctx
y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: var a Γ0
v_shift1 a (f1 a v ᵥ⊛ᵣ f2) =
v_shift1 a (f1 a v) ᵥ⊛ᵣ r_shift1 f2
  -
Γ: ctx ty
Γ2, Γ3: t_ctx
a: ty
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Var top = Var top ᵥ⊛ᵣ r_shift1 f2 now rewrite v_ren_id_r.
  -
Γ0: ctx ty
Γ2, Γ3: t_ctx
y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: var a Γ0
v_shift1 a (f1 a v ᵥ⊛ᵣ f2) =
v_shift1 a (f1 a v) ᵥ⊛ᵣ r_shift1 f2 now unfold v_shift1; rewrite 2 v_ren_ren.
Qed.

Lemma a_shift3_ren_r {Γ1 Γ2 Γ3 A B C} (f1 : Γ1 =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3)
      : a_shift3 (A:=A) (B:=B) (C:=C) (f1 ⊛ᵣ f2) ≡ₐ a_shift3 f1 ⊛ᵣ r_shift3 f2 .
Γ1, Γ2, Γ3: t_ctx
A, B, C: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a_shift3 (f1 ⊛ᵣ f2) ≡ₐ a_shift3 f1 ⊛ᵣ r_shift3 f2
  intros ? v; do 3 (dependent elimination v; cbn; [ now rewrite v_ren_id_r | ]).
Γ0: ctx ty
Γ2, Γ3: t_ctx
y1, y0, y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: var a Γ0
v_shift3 a (f1 a v ᵥ⊛ᵣ f2) =
v_shift3 a (f1 a v) ᵥ⊛ᵣ r_shift3 f2
  unfold v_shift3; now rewrite 2 v_ren_ren.
Qed.

Lemma a_shift1_ren_l {Γ1 Γ2 Γ3 A} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3)
  : a_shift1 (A:=A) (f1 ᵣ⊛ f2) ≡ₐ r_shift1 f1 ᵣ⊛ a_shift1 f2 .
Γ1, Γ2: ctx ty
Γ3: t_ctx
A: ty
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
a_shift1 (f1 ᵣ⊛ f2) ≡ₐ r_shift1 f1 ᵣ⊛ a_shift1 f2
  intros ? i; dependent elimination i; auto.
Qed.

Lemma a_shift3_ren_l {Γ1 Γ2 Γ3 A B C} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3)
      : a_shift3 (A:=A) (B:=B) (C:=C) (f1 ᵣ⊛ f2) ≡ₐ r_shift3 f1 ᵣ⊛ a_shift3 f2 .
Γ1, Γ2: ctx ty
Γ3: t_ctx
A, B, C: ty
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
a_shift3 (f1 ᵣ⊛ f2) ≡ₐ r_shift3 f1 ᵣ⊛ a_shift3 f2
  intros ? v; do 3 (dependent elimination v; auto).
Qed.

Definition t_sub_proper_P Γ A (t : term Γ A) : Prop :=
  forall Δ (f1 f2 : Γ =[val]> Δ), f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2 .
Definition w_sub_proper_P Γ A (v : whn Γ A) : Prop :=
  forall Δ (f1 f2 : Γ =[val]> Δ), f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2 .
Definition s_sub_proper_P Γ (s : state Γ) : Prop :=
  forall Δ (f1 f2 : Γ =[val]> Δ), f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2 .

Lemma sub_proper_prf : syn_ind_args t_sub_proper_P w_sub_proper_P s_sub_proper_P.
syn_ind_args t_sub_proper_P w_sub_proper_P
  s_sub_proper_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_sub_proper_P (Γ ▶ₓ ¬ A) s ->
t_sub_proper_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_sub_proper_P Γ A v -> t_sub_proper_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_sub_proper_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_sub_proper_P (Γ ▶ₓ ↑ A) s ->
t_sub_proper_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_sub_proper_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_proper_P Γ A v ->
forall k : term Γ ¬ B,
t_sub_proper_P Γ ¬ B k ->
t_sub_proper_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_sub_proper_P Γ ¬ A k ->
t_sub_proper_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_sub_proper_P Γ ¬ B k ->
t_sub_proper_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_sub_proper_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_sub_proper_P (Γ ▶ₓ ↑ B) t ->
t_sub_proper_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_sub_proper_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_proper_P Γ A v ->
w_sub_proper_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_sub_proper_P Γ B v ->
w_sub_proper_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_sub_proper_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_sub_proper_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_sub_proper_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_sub_proper_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_sub_proper_P (Γ ▶ₓ ¬ B) t ->
w_sub_proper_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_sub_proper_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_sub_proper_P Γ ¬ A v -> s_sub_proper_P Γ (Cut u v)
  all: unfold t_sub_proper_P, w_sub_proper_P, s_sub_proper_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Mu s `ₜ⊛ f1 = Mu s `ₜ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Val v `ₜ⊛ f1 = Val v `ₜ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> VarR i `ₜ⊛ f1 = VarR i `ₜ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> MuT s `ₜ⊛ f1 = MuT s `ₜ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Boom `ₜ⊛ f1 = Boom `ₜ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2) ->
forall k : term Γ ¬ B,
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> App v k `ₜ⊛ f1 = App v k `ₜ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Fst k `ₜ⊛ f1 = Fst k `ₜ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Snd k `ₜ⊛ f1 = Snd k `ₜ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ↑ B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Case s t `ₜ⊛ f1 = Case s t `ₜ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> VarL i `ᵥ⊛ f1 = VarL i `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Inl v `ᵥ⊛ f1 = Inl v `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Inr v `ᵥ⊛ f1 = Inr v `ᵥ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Tt `ᵥ⊛ f1 = Tt `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Δ : t_ctx)
   (f1
    f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Lam s `ᵥ⊛ f1 = Lam s `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ ¬ B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Pair s t `ᵥ⊛ f1 = Pair s t `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> u `ₜ⊛ f1 = u `ₜ⊛ f2) ->
forall v : term Γ ¬ A,
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> v `ₜ⊛ f1 = v `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Cut u v ₜ⊛ f1 = Cut u v ₜ⊛ f2
  all: intros; cbn; f_equal.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ¬ A) s (Δ ▶ₓ ¬ A) (a_shift1 f1) =
s_subst (Γ ▶ₓ ¬ A) s (Δ ▶ₓ ¬ A) (a_shift1 f2)
Γ: t_ctx
A: pre_ty
v: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ↑ A) s (Δ ▶ₓ ↑ A) (a_shift1 f1) =
s_subst (Γ ▶ₓ ↑ A) s (Δ ▶ₓ ↑ A) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty
v: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2
k: term Γ ¬ B
H0: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty
v: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2
k: term Γ ¬ B
H0: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
k `ₜ⊛ f1 = k `ₜ⊛ f2
Γ: t_ctx
A, B: pre_ty
k: term Γ ¬ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
k `ₜ⊛ f1 = k `ₜ⊛ f2
Γ: t_ctx
A, B: pre_ty
k: term Γ ¬ B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> k `ₜ⊛ f1 = k `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
k `ₜ⊛ f1 = k `ₜ⊛ f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ↑ A) s (Δ ▶ₓ ↑ A) (a_shift1 f1) =
s_subst (Γ ▶ₓ ↑ A) s (Δ ▶ₓ ↑ A) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ↑ B) t (Δ ▶ₓ ↑ B) (a_shift1 f1) =
s_subst (Γ ▶ₓ ↑ B) t (Δ ▶ₓ ↑ B) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty
v: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty
v: whn Γ B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
v `ᵥ⊛ f1 = v `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Δ : t_ctx)
  (f1
   f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val
        ]> Δ), f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Δ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 f1) =
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Δ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ¬ A) s (Δ ▶ₓ ¬ A) (a_shift1 f1) =
s_subst (Γ ▶ₓ ¬ A) s (Δ ▶ₓ ¬ A) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
s_subst (Γ ▶ₓ ¬ B) t (Δ ▶ₓ ¬ B) (a_shift1 f1) =
s_subst (Γ ▶ₓ ¬ B) t (Δ ▶ₓ ¬ B) (a_shift1 f2)
Γ: t_ctx
A: pre_ty
u: term Γ ↑ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> u `ₜ⊛ f1 = u `ₜ⊛ f2
v: term Γ ¬ A
H0: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ₜ⊛ f1 = v `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
u `ₜ⊛ f1 = u `ₜ⊛ f2
Γ: t_ctx
A: pre_ty
u: term Γ ↑ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> u `ₜ⊛ f1 = u `ₜ⊛ f2
v: term Γ ¬ A
H0: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> v `ₜ⊛ f1 = v `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
v `ₜ⊛ f1 = v `ₜ⊛ f2
  all: first [ apply H | apply H0 | apply H1 | apply H2 ]; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ↑ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Δ : t_ctx)
  (f1
   f2 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val
        ]> Δ), f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift3 f1 ≡ₐ a_shift3 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ ¬ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> t ₜ⊛ f1 = t ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H1: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
  all: first [ apply a_shift1_eq | apply a_shift3_eq ]; auto.
Qed.

#[global] Instance t_sub_eq {Γ a t Δ} : Proper (asgn_eq _ _ ==> eq) (t_subst Γ a t Δ).
Γ: t_ctx
a: ty
t: term Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (t_subst Γ a t Δ)
  intros f1 f2 H1; now apply (term_ind_mut _ _ _ sub_proper_prf).
Qed.

#[global] Instance w_sub_eq {Γ a v Δ} : Proper (asgn_eq _ _ ==> eq) (w_subst Γ a v Δ).
Γ: t_ctx
a: pre_ty
v: whn Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (w_subst Γ a v Δ)
  intros f1 f2 H1; now apply (whn_ind_mut _ _ _ sub_proper_prf).
Qed.

#[global] Instance s_sub_eq {Γ s Δ} : Proper (asgn_eq _ _ ==> eq) (s_subst Γ s Δ).
Γ: t_ctx
s: state Γ
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (s_subst Γ s Δ)
  intros f1 f2 H1; now apply (state_ind_mut _ _ _ sub_proper_prf).
Qed.

#[global] Instance v_sub_eq {Γ a v Δ} : Proper (asgn_eq _ _ ==> eq) (v_subst Γ a v Δ).
Γ: t_ctx
a: ty
v: val Γ a
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ a v Δ)
  destruct a.
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ ↑ p v Δ)
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ ¬ p v Δ)
  -
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ ↑ p v Δ) now apply w_sub_eq.
  -
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ ¬ p v Δ) now apply t_sub_eq.
Qed.

#[global] Instance a_comp_eq {Γ1 Γ2 Γ3}
  : Proper (asgn_eq _ _ ==> asgn_eq _ _ ==> asgn_eq _ _) (@a_comp _ _ _ _ _ Γ1 Γ2 Γ3).
Γ1, Γ2, Γ3: ctx ty
Proper
  (asgn_eq Γ1 Γ2 ==> asgn_eq Γ2 Γ3 ==> asgn_eq Γ1 Γ3)
  a_comp
  intros ? ? H1 ? ? H2 ? ?; cbn; rewrite H1; now eapply v_sub_eq.
Qed.

Definition t_ren_sub_P Γ1 A (t : term Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3),
    (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ (f1 ⊛ᵣ f2) .
Definition w_ren_sub_P Γ1 A (v : whn Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3),
    (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ (f1 ⊛ᵣ f2) .
Definition s_ren_sub_P Γ1 (s : state Γ1) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3),
    (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ (f1 ⊛ᵣ f2) .
Lemma ren_sub_prf : syn_ind_args t_ren_sub_P w_ren_sub_P s_ren_sub_P.
syn_ind_args t_ren_sub_P w_ren_sub_P s_ren_sub_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_ren_sub_P (Γ ▶ₓ ¬ A) s -> t_ren_sub_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_ren_sub_P Γ A v -> t_ren_sub_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_ren_sub_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_ren_sub_P (Γ ▶ₓ ↑ A) s -> t_ren_sub_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_ren_sub_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_sub_P Γ A v ->
forall k : term Γ ¬ B,
t_ren_sub_P Γ ¬ B k ->
t_ren_sub_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_ren_sub_P Γ ¬ A k ->
t_ren_sub_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_ren_sub_P Γ ¬ B k ->
t_ren_sub_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_ren_sub_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_ren_sub_P (Γ ▶ₓ ↑ B) t ->
t_ren_sub_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_ren_sub_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_ren_sub_P Γ A v -> w_ren_sub_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_ren_sub_P Γ B v -> w_ren_sub_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_ren_sub_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_ren_sub_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_ren_sub_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_ren_sub_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_ren_sub_P (Γ ▶ₓ ¬ B) t ->
w_ren_sub_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_ren_sub_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_ren_sub_P Γ ¬ A v -> s_ren_sub_P Γ (Cut u v)
  all: unfold t_ren_sub_P, w_ren_sub_P, s_ren_sub_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Mu s `ₜ⊛ f1) ₜ⊛ᵣ f2 = Mu s `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Val v `ₜ⊛ f1) ₜ⊛ᵣ f2 = Val v `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(VarR i `ₜ⊛ f1) ₜ⊛ᵣ f2 = VarR i `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(MuT s `ₜ⊛ f1) ₜ⊛ᵣ f2 = MuT s `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Boom `ₜ⊛ f1) ₜ⊛ᵣ f2 = Boom `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall k : term Γ ¬ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (k `ₜ⊛ f1) ₜ⊛ᵣ f2 = k `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(App v k `ₜ⊛ f1) ₜ⊛ᵣ f2 = App v k `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (k `ₜ⊛ f1) ₜ⊛ᵣ f2 = k `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Fst k `ₜ⊛ f1) ₜ⊛ᵣ f2 = Fst k `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (k `ₜ⊛ f1) ₜ⊛ᵣ f2 = k `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Snd k `ₜ⊛ f1) ₜ⊛ᵣ f2 = Snd k `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Case s t `ₜ⊛ f1) ₜ⊛ᵣ f2 = Case s t `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(VarL i `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = VarL i `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Inl v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = Inl v `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Inr v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = Inr v `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Tt `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = Tt `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Lam s `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = Lam s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Pair s t `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = Pair s t `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (u `ₜ⊛ f1) ₜ⊛ᵣ f2 = u `ₜ⊛ f1 ⊛ᵣ f2) ->
forall v : term Γ ¬ A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (v `ₜ⊛ f1) ₜ⊛ᵣ f2 = v `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Cut u v ₜ⊛ f1) ₛ⊛ᵣ f2 = Cut u v ₜ⊛ f1 ⊛ᵣ f2
  all: intros; cbn; f_equal; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ¬ A) s (Γ2 ▶ₓ ¬ A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ↑ A) s (Γ2 ▶ₓ ↑ A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ↑ A) s (Γ2 ▶ₓ ↑ A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ↑ B) t (Γ2 ▶ₓ ↑ B) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ↑ B) t (Γ3 ▶ₓ ↑ B) (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val
        ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Γ2 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 f1)
ₛ⊛ᵣ r_shift3 f2 =
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Γ3 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (a_shift3 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ¬ A) s (Γ2 ▶ₓ ¬ A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t ₜ⊛ f1) ₛ⊛ᵣ f2 = t ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ ¬ B) t (Γ2 ▶ₓ ¬ B) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ ¬ B) t (Γ3 ▶ₓ ¬ B) (a_shift1 (f1 ⊛ᵣ f2))
  all: first [ rewrite a_shift1_ren_r | rewrite a_shift3_ren_r ]; auto.
Qed.

Lemma t_ren_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3) A (t : term Γ1 A)
  : (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ (f1 ⊛ᵣ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
A: ty
t: term Γ1 A
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
  now apply (term_ind_mut _ _ _ ren_sub_prf).
Qed.
Lemma w_ren_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3) A (v : whn Γ1 A)
  : (v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ (f1 ⊛ᵣ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
A: pre_ty
v: whn Γ1 A
(v `ᵥ⊛ f1) `ᵥ⊛ᵣ f2 = v `ᵥ⊛ f1 ⊛ᵣ f2
  now apply (whn_ind_mut _ _ _ ren_sub_prf).
Qed.
Lemma s_ren_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3) (s : state Γ1)
  : (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ (f1 ⊛ᵣ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s: state Γ1
(s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
  now apply (state_ind_mut _ _ _ ren_sub_prf).
Qed.
Lemma v_ren_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 ⊆ Γ3) A (v : val Γ1 A)
  : (v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ (f1 ⊛ᵣ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
A: ty
v: val Γ1 A
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2
  destruct A.
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ↑ p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2
  -
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ↑ p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2 now apply w_ren_sub.
  -
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2 now apply t_ren_sub.
Qed.

Definition t_sub_ren_P Γ1 A (t : term Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3),
    (t ₜ⊛ᵣ f1) `ₜ⊛ f2 = t `ₜ⊛ (f1 ᵣ⊛ f2).
Definition w_sub_ren_P Γ1 A (v : whn Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3),
    (v `ᵥ⊛ᵣ f1) `ᵥ⊛ f2 = v `ᵥ⊛ (f1 ᵣ⊛ f2).
Definition s_sub_ren_P Γ1 (s : state Γ1) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3),
    (s ₛ⊛ᵣ f1) ₜ⊛ f2 = s ₜ⊛ (f1 ᵣ⊛ f2).

Lemma sub_ren_prf : syn_ind_args t_sub_ren_P w_sub_ren_P s_sub_ren_P.
syn_ind_args t_sub_ren_P w_sub_ren_P s_sub_ren_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_sub_ren_P (Γ ▶ₓ ¬ A) s -> t_sub_ren_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_sub_ren_P Γ A v -> t_sub_ren_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_sub_ren_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_sub_ren_P (Γ ▶ₓ ↑ A) s -> t_sub_ren_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_sub_ren_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_ren_P Γ A v ->
forall k : term Γ ¬ B,
t_sub_ren_P Γ ¬ B k ->
t_sub_ren_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_sub_ren_P Γ ¬ A k ->
t_sub_ren_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_sub_ren_P Γ ¬ B k ->
t_sub_ren_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_sub_ren_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_sub_ren_P (Γ ▶ₓ ↑ B) t ->
t_sub_ren_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_sub_ren_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_ren_P Γ A v -> w_sub_ren_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_sub_ren_P Γ B v -> w_sub_ren_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_sub_ren_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_sub_ren_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_sub_ren_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_sub_ren_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_sub_ren_P (Γ ▶ₓ ¬ B) t ->
w_sub_ren_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_sub_ren_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_sub_ren_P Γ ¬ A v -> s_sub_ren_P Γ (Cut u v)
  all: unfold t_sub_ren_P, w_sub_ren_P, s_sub_ren_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Mu s ₜ⊛ᵣ f1 `ₜ⊛ f2 = Mu s `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = v `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Val v ₜ⊛ᵣ f1 `ₜ⊛ f2 = Val v `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 =[ val ]> Γ3),
VarR i ₜ⊛ᵣ f1 `ₜ⊛ f2 = VarR i `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
MuT s ₜ⊛ᵣ f1 `ₜ⊛ f2 = MuT s `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Boom ₜ⊛ᵣ f1 `ₜ⊛ f2 = Boom `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = v `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall k : term Γ ¬ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 k ₜ⊛ᵣ f1 `ₜ⊛ f2 = k `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
App v k ₜ⊛ᵣ f1 `ₜ⊛ f2 = App v k `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 k ₜ⊛ᵣ f1 `ₜ⊛ f2 = k `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Fst k ₜ⊛ᵣ f1 `ₜ⊛ f2 = Fst k `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 k ₜ⊛ᵣ f1 `ₜ⊛ f2 = k `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Snd k ₜ⊛ᵣ f1 `ₜ⊛ f2 = Snd k `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Case s t ₜ⊛ᵣ f1 `ₜ⊛ f2 = Case s t `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 =[ val ]> Γ3),
VarL i `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = VarL i `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = v `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Inl v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Inl v `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = v `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Inr v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Inr v `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Tt `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Tt `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Lam s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Lam s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Pair s t `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Pair s t `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 u ₜ⊛ᵣ f1 `ₜ⊛ f2 = u `ₜ⊛ f1 ᵣ⊛ f2) ->
forall v : term Γ ¬ A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 v ₜ⊛ᵣ f1 `ₜ⊛ f2 = v `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Cut u v ₛ⊛ᵣ f1 ₜ⊛ f2 = Cut u v ₜ⊛ f1 ᵣ⊛ f2
  all: intros; cbn; f_equal; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ A) (s ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ¬ A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ A) (s ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ↑ A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ A) (s ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ↑ A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ B) (t ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ↑ B)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ B) t (Γ3 ▶ₓ ↑ B) (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (s ₛ⊛ᵣ r_shift3 f1) (Γ3 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (a_shift3 f2) =
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Γ3 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (a_shift3 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ A) (s ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ¬ A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₛ⊛ᵣ f1 ₜ⊛ f2 = t ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ B) (t ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ ¬ B)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ B) t (Γ3 ▶ₓ ¬ B) (a_shift1 (f1 ᵣ⊛ f2))
  all: first [ rewrite a_shift1_ren_l | rewrite a_shift3_ren_l ]; auto.
Qed.

Lemma t_sub_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3) A (t : term Γ1 A)
  : (t ₜ⊛ᵣ f1) `ₜ⊛ f2 = t `ₜ⊛ (f1 ᵣ⊛ f2).
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
A: ty
t: term Γ1 A
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
  now apply (term_ind_mut _ _ _ sub_ren_prf).
Qed.
Lemma w_sub_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3) A (v : whn Γ1 A)
  : (v `ᵥ⊛ᵣ f1) `ᵥ⊛ f2 = v `ᵥ⊛ (f1 ᵣ⊛ f2).
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
A: pre_ty
v: whn Γ1 A
v `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = v `ᵥ⊛ f1 ᵣ⊛ f2
  now apply (whn_ind_mut _ _ _ sub_ren_prf).
Qed.
Lemma s_sub_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3) (s : state Γ1)
  : (s ₛ⊛ᵣ f1) ₜ⊛ f2 = s ₜ⊛ (f1 ᵣ⊛ f2).
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s: state Γ1
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
  now apply (state_ind_mut _ _ _ sub_ren_prf).
Qed.
Lemma v_sub_ren {Γ1 Γ2 Γ3} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3) A (v : val Γ1 A)
  : (v ᵥ⊛ᵣ f1) ᵥ⊛ f2 = v ᵥ⊛ (f1 ᵣ⊛ f2).
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
A: ty
v: val Γ1 A
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2
  destruct A.
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ↑ p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ¬ p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2
  -
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ↑ p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2 now apply w_sub_ren.
  -
Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ¬ p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2 now apply t_sub_ren.
Qed.

Lemma v_sub_id_r {Γ Δ} (f : Γ =[val]> Δ) A (i : Γ ∋ A) : Var i ᵥ⊛ f = f A i.
Γ, Δ: t_ctx
f: Γ =[ val ]> Δ
A: ty
i: Γ ∋ A
Var i ᵥ⊛ f = f A i
  now destruct A.
Qed.

Lemma a_shift1_comp {Γ1 Γ2 Γ3 A} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3)
  : @a_shift1 _ _ A (f1 ⊛ f2) ≡ₐ a_shift1 f1 ⊛ a_shift1 f2 .
Γ1, Γ2, Γ3: t_ctx
A: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
a_shift1 (f1 ⊛ f2) ≡ₐ a_shift1 f1 ⊛ a_shift1 f2
  intros x i; dependent elimination i; cbn.
Γ: ctx ty
Γ2, Γ3: t_ctx
x: ty
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Var top =
v_subst (Γ2 ▶ₓ x) x (Var top) (Γ3 ▶ₓ x) (a_shift1 f2)
Γ0: ctx ty
Γ2, Γ3: t_ctx
y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
x: ty
v: var x Γ0
v_shift1 x (v_subst Γ2 x (f1 x v) Γ3 f2) =
v_subst (Γ2 ▶ₓ y) x (v_shift1 x (f1 x v)) (Γ3 ▶ₓ y)
  (a_shift1 f2)
  -
Γ: ctx ty
Γ2, Γ3: t_ctx
x: ty
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Var top =
v_subst (Γ2 ▶ₓ x) x (Var top) (Γ3 ▶ₓ x) (a_shift1 f2) now rewrite v_sub_id_r.
  -
Γ0: ctx ty
Γ2, Γ3: t_ctx
y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
x: ty
v: var x Γ0
v_shift1 x (v_subst Γ2 x (f1 x v) Γ3 f2) =
v_subst (Γ2 ▶ₓ y) x (v_shift1 x (f1 x v)) (Γ3 ▶ₓ y)
  (a_shift1 f2) now unfold v_shift1; rewrite v_ren_sub, v_sub_ren.
Qed.

Lemma a_shift3_comp {Γ1 Γ2 Γ3 A B C} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3)
  : @a_shift3 _ _ A B C (f1 ⊛ f2) ≡ₐ a_shift3 f1 ⊛ a_shift3 f2 .
Γ1, Γ2, Γ3: t_ctx
A, B, C: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
a_shift3 (f1 ⊛ f2) ≡ₐ a_shift3 f1 ⊛ a_shift3 f2
  intros ? v; do 3 (dependent elimination v; cbn; [ now rewrite v_sub_id_r | ]).
Γ0: ctx ty
Γ2, Γ3: t_ctx
y1, y0, y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
a: ty
v: var a Γ0
v_shift3 a (v_subst Γ2 a (f1 a v) Γ3 f2) =
v_subst (Γ2 ▶ₓ y1 ▶ₓ y0 ▶ₓ y) a (v_shift3 a (f1 a v))
  (Γ3 ▶ₓ y1 ▶ₓ y0 ▶ₓ y) (a_shift3 f2)
  now unfold v_shift3; rewrite v_ren_sub, v_sub_ren.
Qed.

Definition t_sub_sub_P Γ1 A (t : term Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3),
    (t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ (f1 ⊛ f2) .
Definition w_sub_sub_P Γ1 A (v : whn Γ1 A) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3),
    (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ (f1 ⊛ f2) .
Definition s_sub_sub_P Γ1 (s : state Γ1) : Prop :=
  forall Γ2 Γ3 (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3),
    (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ (f1 ⊛ f2) .

Lemma sub_sub_prf : syn_ind_args t_sub_sub_P w_sub_sub_P s_sub_sub_P.
syn_ind_args t_sub_sub_P w_sub_sub_P s_sub_sub_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_sub_sub_P (Γ ▶ₓ ¬ A) s -> t_sub_sub_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_sub_sub_P Γ A v -> t_sub_sub_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_sub_sub_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_sub_sub_P (Γ ▶ₓ ↑ A) s -> t_sub_sub_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_sub_sub_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_sub_P Γ A v ->
forall k : term Γ ¬ B,
t_sub_sub_P Γ ¬ B k ->
t_sub_sub_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_sub_sub_P Γ ¬ A k ->
t_sub_sub_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_sub_sub_P Γ ¬ B k ->
t_sub_sub_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_sub_sub_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_sub_sub_P (Γ ▶ₓ ↑ B) t ->
t_sub_sub_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_sub_sub_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_sub_P Γ A v -> w_sub_sub_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_sub_sub_P Γ B v -> w_sub_sub_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_sub_sub_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_sub_sub_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_sub_sub_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_sub_sub_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_sub_sub_P (Γ ▶ₓ ¬ B) t ->
w_sub_sub_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_sub_sub_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_sub_sub_P Γ ¬ A v -> s_sub_sub_P Γ (Cut u v)
  all: unfold t_sub_sub_P, w_sub_sub_P, s_sub_sub_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Mu s `ₜ⊛ f1) `ₜ⊛ f2 = Mu s `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Val v `ₜ⊛ f1) `ₜ⊛ f2 = Val v `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(VarR i `ₜ⊛ f1) `ₜ⊛ f2 = VarR i `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(MuT s `ₜ⊛ f1) `ₜ⊛ f2 = MuT s `ₜ⊛ f1 ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Boom `ₜ⊛ f1) `ₜ⊛ f2 = Boom `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ f1 ⊛ f2) ->
forall k : term Γ ¬ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (k `ₜ⊛ f1) `ₜ⊛ f2 = k `ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(App v k `ₜ⊛ f1) `ₜ⊛ f2 = App v k `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (k `ₜ⊛ f1) `ₜ⊛ f2 = k `ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Fst k `ₜ⊛ f1) `ₜ⊛ f2 = Fst k `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (k `ₜ⊛ f1) `ₜ⊛ f2 = k `ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Snd k `ₜ⊛ f1) `ₜ⊛ f2 = Snd k `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2) ->
forall t : state (Γ ▶ₓ ↑ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Case s t `ₜ⊛ f1) `ₜ⊛ f2 = Case s t `ₜ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(VarL i `ᵥ⊛ f1) `ᵥ⊛ f2 = VarL i `ᵥ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Inl v `ᵥ⊛ f1) `ᵥ⊛ f2 = Inl v `ᵥ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Inr v `ᵥ⊛ f1) `ᵥ⊛ f2 = Inr v `ᵥ⊛ f1 ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Tt `ᵥ⊛ f1) `ᵥ⊛ f2 = Tt `ᵥ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Lam s `ᵥ⊛ f1) `ᵥ⊛ f2 = Lam s `ᵥ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2) ->
forall t : state (Γ ▶ₓ ¬ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Pair s t `ᵥ⊛ f1) `ᵥ⊛ f2 = Pair s t `ᵥ⊛ f1 ⊛ f2
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (u `ₜ⊛ f1) `ₜ⊛ f2 = u `ₜ⊛ f1 ⊛ f2) ->
forall v : term Γ ¬ A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 (v `ₜ⊛ f1) `ₜ⊛ f2 = v `ₜ⊛ f1 ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(Cut u v ₜ⊛ f1) ₜ⊛ f2 = Cut u v ₜ⊛ f1 ⊛ f2
  all: intros; cbn; f_equal; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ A)
  (s_subst (Γ ▶ₓ ¬ A) s (Γ2 ▶ₓ ¬ A) (a_shift1 f1))
  (Γ3 ▶ₓ ¬ A) (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ A)
  (s_subst (Γ ▶ₓ ↑ A) s (Γ2 ▶ₓ ↑ A) (a_shift1 f1))
  (Γ3 ▶ₓ ↑ A) (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ A)
  (s_subst (Γ ▶ₓ ↑ A) s (Γ2 ▶ₓ ↑ A) (a_shift1 f1))
  (Γ3 ▶ₓ ↑ A) (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ A) s (Γ3 ▶ₓ ↑ A) (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
t: state (Γ ▶ₓ ↑ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ B)
  (s_subst (Γ ▶ₓ ↑ B) t (Γ2 ▶ₓ ↑ B) (a_shift1 f1))
  (Γ3 ▶ₓ ↑ B) (a_shift1 f2) =
s_subst (Γ ▶ₓ ↑ B) t (Γ3 ▶ₓ ↑ B) (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) =[ val
        ]> Γ2) (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
     (Γ2 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 f1))
  (Γ3 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 f2) =
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Γ3 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
  (a_shift3 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ A)
  (s_subst (Γ ▶ₓ ¬ A) s (Γ2 ▶ₓ ¬ A) (a_shift1 f1))
  (Γ3 ▶ₓ ¬ A) (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ A) s (Γ3 ▶ₓ ¬ A) (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
t: state (Γ ▶ₓ ¬ B)
H0: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ ¬ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t ₜ⊛ f1) ₜ⊛ f2 = t ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ ¬ B)
  (s_subst (Γ ▶ₓ ¬ B) t (Γ2 ▶ₓ ¬ B) (a_shift1 f1))
  (Γ3 ▶ₓ ¬ B) (a_shift1 f2) =
s_subst (Γ ▶ₓ ¬ B) t (Γ3 ▶ₓ ¬ B) (a_shift1 (f1 ⊛ f2))
  all: first [ rewrite a_shift1_comp | rewrite a_shift3_comp ]; auto.
Qed.

Lemma t_sub_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3) A (t : term Γ1 A)
  : (t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ (f1 ⊛ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
A: ty
t: term Γ1 A
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
  now apply (term_ind_mut _ _ _ sub_sub_prf).
Qed.
Lemma w_sub_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3) A (v : whn Γ1 A)
  : (v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ (f1 ⊛ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
A: pre_ty
v: whn Γ1 A
(v `ᵥ⊛ f1) `ᵥ⊛ f2 = v `ᵥ⊛ f1 ⊛ f2
  now apply (whn_ind_mut _ _ _ sub_sub_prf).
Qed.
Lemma s_sub_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3) (s : state Γ1)
  : (s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ (f1 ⊛ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s: state Γ1
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
  now apply (state_ind_mut _ _ _ sub_sub_prf).
Qed.
Lemma v_sub_sub {Γ1 Γ2 Γ3} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3) A (v : val Γ1 A)
  : (v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ (f1 ⊛ f2) .
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
A: ty
v: val Γ1 A
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2
  destruct A.
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ↑ p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2
  -
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ↑ p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2 now apply w_sub_sub.
  -
Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty
v: val Γ1 ¬ p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2 now apply t_sub_sub.
Qed.

Lemma a_comp_assoc {Γ1 Γ2 Γ3 Γ4} (u : Γ1 =[val]> Γ2) (v : Γ2 =[val]> Γ3) (w : Γ3 =[val]> Γ4)
           : (u ⊛ v) ⊛ w ≡ₐ u ⊛ (v ⊛ w).
Γ1, Γ2, Γ3, Γ4: t_ctx
u: Γ1 =[ val ]> Γ2
v: Γ2 =[ val ]> Γ3
w: Γ3 =[ val ]> Γ4
(u ⊛ v) ⊛ w ≡ₐ u ⊛ (v ⊛ w)
  intros ? i; unfold a_comp; now apply v_sub_sub.
Qed.

Definition t_sub_id_l_P Γ A (t : term Γ A) : Prop := t `ₜ⊛ Var = t.
Definition w_sub_id_l_P Γ A (v : whn Γ A) : Prop := v `ᵥ⊛ Var = v.
Definition s_sub_id_l_P Γ (s : state Γ) : Prop := s ₜ⊛ Var = s.

Lemma sub_id_l_prf : syn_ind_args t_sub_id_l_P w_sub_id_l_P s_sub_id_l_P.
syn_ind_args t_sub_id_l_P w_sub_id_l_P s_sub_id_l_P
  econstructor.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s_sub_id_l_P (Γ ▶ₓ ¬ A) s -> t_sub_id_l_P Γ ↑ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
w_sub_id_l_P Γ A v -> t_sub_id_l_P Γ ↑ A (Val v)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
t_sub_id_l_P Γ ¬ A (VarR i)
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s_sub_id_l_P (Γ ▶ₓ ↑ A) s ->
t_sub_id_l_P Γ ¬ A (MuT s)
forall Γ : t_ctx, t_sub_id_l_P Γ ¬ `0 Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_id_l_P Γ A v ->
forall k : term Γ ¬ B,
t_sub_id_l_P Γ ¬ B k ->
t_sub_id_l_P Γ ¬ (A `→ B) (App v k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
t_sub_id_l_P Γ ¬ A k ->
t_sub_id_l_P Γ ¬ (A `× B) (Fst k)
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
t_sub_id_l_P Γ ¬ B k ->
t_sub_id_l_P Γ ¬ (A `× B) (Snd k)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s_sub_id_l_P (Γ ▶ₓ ↑ A) s ->
forall t : state (Γ ▶ₓ ↑ B),
s_sub_id_l_P (Γ ▶ₓ ↑ B) t ->
t_sub_id_l_P Γ ¬ (A `+ B) (Case s t)
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
w_sub_id_l_P Γ A (VarL i)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
w_sub_id_l_P Γ A v -> w_sub_id_l_P Γ (A `+ B) (Inl v)
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
w_sub_id_l_P Γ B v -> w_sub_id_l_P Γ (A `+ B) (Inr v)
forall Γ : t_ctx, w_sub_id_l_P Γ `1 Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s_sub_id_l_P (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s ->
w_sub_id_l_P Γ (A `→ B) (Lam s)
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s_sub_id_l_P (Γ ▶ₓ ¬ A) s ->
forall t : state (Γ ▶ₓ ¬ B),
s_sub_id_l_P (Γ ▶ₓ ¬ B) t ->
w_sub_id_l_P Γ (A `× B) (Pair s t)
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
t_sub_id_l_P Γ ↑ A u ->
forall v : term Γ ¬ A,
t_sub_id_l_P Γ ¬ A v -> s_sub_id_l_P Γ (Cut u v)
  all: unfold t_sub_id_l_P, w_sub_id_l_P, s_sub_id_l_P.
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ¬ A)),
s ₜ⊛ Var = s -> Mu s `ₜ⊛ Var = Mu s
forall (Γ : t_ctx) (A : pre_ty) (v : whn Γ A),
v `ᵥ⊛ Var = v -> Val v `ₜ⊛ Var = Val v
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ¬ A),
VarR i `ₜ⊛ Var = VarR i
forall (Γ : t_ctx) (A : pre_ty) (s : state (Γ ▶ₓ ↑ A)),
s ₜ⊛ Var = s -> MuT s `ₜ⊛ Var = MuT s
forall Γ : t_ctx, Boom `ₜ⊛ Var = Boom
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
v `ᵥ⊛ Var = v ->
forall k : term Γ ¬ B,
k `ₜ⊛ Var = k -> App v k `ₜ⊛ Var = App v k
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ A),
k `ₜ⊛ Var = k -> Fst k `ₜ⊛ Var = Fst k
forall (Γ : t_ctx) (A B : pre_ty) (k : term Γ ¬ B),
k `ₜ⊛ Var = k -> Snd k `ₜ⊛ Var = Snd k
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ A)),
s ₜ⊛ Var = s ->
forall t : state (Γ ▶ₓ ↑ B),
t ₜ⊛ Var = t -> Case s t `ₜ⊛ Var = Case s t
forall (Γ : t_ctx) (A : pre_ty) (i : Γ ∋ ↑ A),
VarL i `ᵥ⊛ Var = VarL i
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ A),
v `ᵥ⊛ Var = v -> Inl v `ᵥ⊛ Var = Inl v
forall (Γ : t_ctx) (A B : pre_ty) (v : whn Γ B),
v `ᵥ⊛ Var = v -> Inr v `ᵥ⊛ Var = Inr v
forall Γ : t_ctx, Tt `ᵥ⊛ Var = Tt
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)),
s ₜ⊛ Var = s -> Lam s `ᵥ⊛ Var = Lam s
forall (Γ : t_ctx) (A B : pre_ty)
  (s : state (Γ ▶ₓ ¬ A)),
s ₜ⊛ Var = s ->
forall t : state (Γ ▶ₓ ¬ B),
t ₜ⊛ Var = t -> Pair s t `ᵥ⊛ Var = Pair s t
forall (Γ : t_ctx) (A : pre_ty) (u : term Γ ↑ A),
u `ₜ⊛ Var = u ->
forall v : term Γ ¬ A,
v `ₜ⊛ Var = v -> Cut u v ₜ⊛ Var = Cut u v
  all: intros; cbn; f_equal; auto.
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₜ⊛ Var = s
s_subst (Γ ▶ₓ ¬ A) s (Γ ▶ₓ ¬ A) (a_shift1 Var) = s
Γ: t_ctx
A: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₜ⊛ Var = s
s_subst (Γ ▶ₓ ↑ A) s (Γ ▶ₓ ↑ A) (a_shift1 Var) = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₜ⊛ Var = s
t: state (Γ ▶ₓ ↑ B)
H0: t ₜ⊛ Var = t
s_subst (Γ ▶ₓ ↑ A) s (Γ ▶ₓ ↑ A) (a_shift1 Var) = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ A)
H: s ₜ⊛ Var = s
t: state (Γ ▶ₓ ↑ B)
H0: t ₜ⊛ Var = t
s_subst (Γ ▶ₓ ↑ B) t (Γ ▶ₓ ↑ B) (a_shift1 Var) = t
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
H: s ₜ⊛ Var = s
s_subst (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) s
  (Γ ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B) (a_shift3 Var) = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₜ⊛ Var = s
t: state (Γ ▶ₓ ¬ B)
H0: t ₜ⊛ Var = t
s_subst (Γ ▶ₓ ¬ A) s (Γ ▶ₓ ¬ A) (a_shift1 Var) = s
Γ: t_ctx
A, B: pre_ty
s: state (Γ ▶ₓ ¬ A)
H: s ₜ⊛ Var = s
t: state (Γ ▶ₓ ¬ B)
H0: t ₜ⊛ Var = t
s_subst (Γ ▶ₓ ¬ B) t (Γ ▶ₓ ¬ B) (a_shift1 Var) = t
  all: first [ rewrite a_shift1_id | rewrite a_shift3_id ]; auto.
Qed.

Lemma t_sub_id_l {Γ} A (t : term Γ A) : t `ₜ⊛ Var = t.
Γ: t_ctx
A: ty
t: term Γ A
t `ₜ⊛ Var = t
  now apply (term_ind_mut _ _ _ sub_id_l_prf).
Qed.
Lemma w_sub_id_l {Γ} A (v : whn Γ A) : v `ᵥ⊛ Var = v.
Γ: t_ctx
A: pre_ty
v: whn Γ A
v `ᵥ⊛ Var = v
  now apply (whn_ind_mut _ _ _ sub_id_l_prf).
Qed.
Lemma s_sub_id_l {Γ} (s : state Γ) : s ₜ⊛ Var = s.
Γ: t_ctx
s: state Γ
s ₜ⊛ Var = s
  now apply (state_ind_mut _ _ _ sub_id_l_prf).
Qed.
Lemma v_sub_id_l {Γ} A (v : val Γ A) : v ᵥ⊛ Var = v.
Γ: t_ctx
A: ty
v: val Γ A
v ᵥ⊛ Var = v
  destruct A.
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
v ᵥ⊛ Var = v
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
v ᵥ⊛ Var = v
  -
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
v ᵥ⊛ Var = v now apply w_sub_id_l.
  -
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
v ᵥ⊛ Var = v now apply t_sub_id_l.
Qed.

Lemma sub1_sub {Γ Δ A} (f : Γ =[val]> Δ) (v : val Γ A) :
  a_shift1 f ⊛ asgn1 (v ᵥ⊛ f) ≡ₐ asgn1 v ⊛ f.
Γ, Δ: t_ctx
A: ty
f: Γ =[ val ]> Δ
v: val Γ A
a_shift1 f ⊛ ₁[ v ᵥ⊛ f] ≡ₐ ₁[ v] ⊛ f
  intros ? h; dependent elimination h; cbn.
Γ0: ctx ty
Δ: t_ctx
a: ty
f: Γ0 =[ val ]> Δ
v: val Γ0 a
v_subst (Δ ▶ₓ a) a (Var top) Δ ₁[ v_subst Γ0 a v Δ f] =
v_subst Γ0 a v Δ f
Γ1: ctx ty
Δ: t_ctx
y: ty
f: Γ1 =[ val ]> Δ
v: val Γ1 y
a: ty
v0: var a Γ1
v_subst (Δ ▶ₓ y) a (v_shift1 a (f a v0)) Δ
  ₁[ v_subst Γ1 y v Δ f] = v_subst Γ1 a (Var v0) Δ f
  -
Γ0: ctx ty
Δ: t_ctx
a: ty
f: Γ0 =[ val ]> Δ
v: val Γ0 a
v_subst (Δ ▶ₓ a) a (Var top) Δ ₁[ v_subst Γ0 a v Δ f] =
v_subst Γ0 a v Δ f now rewrite v_sub_id_r.
  -
Γ1: ctx ty
Δ: t_ctx
y: ty
f: Γ1 =[ val ]> Δ
v: val Γ1 y
a: ty
v0: var a Γ1
v_subst (Δ ▶ₓ y) a (v_shift1 a (f a v0)) Δ
  ₁[ v_subst Γ1 y v Δ f] = v_subst Γ1 a (Var v0) Δ f unfold v_shift1; rewrite v_sub_ren, v_sub_id_r.
Γ1: ctx ty
Δ: t_ctx
y: ty
f: Γ1 =[ val ]> Δ
v: val Γ1 y
a: ty
v0: var a Γ1
f a v0 ᵥ⊛ r_pop ᵣ⊛ ₁[ v_subst Γ1 y v Δ f] = f a v0
    now apply v_sub_id_l.
Qed.

Lemma sub1_ren {Γ Δ A} (f : Γ ⊆ Δ) (v : val Γ A) :
  r_shift1 f ᵣ⊛ asgn1 (v ᵥ⊛ᵣ f) ≡ₐ asgn1 v ⊛ᵣ f.
Γ, Δ: ctx ty
A: ty
f: Γ ⊆ Δ
v: val Γ A
r_shift1 f ᵣ⊛ ₁[ v ᵥ⊛ᵣ f] ≡ₐ ₁[ v] ⊛ᵣ f
  intros ? h; dependent elimination h; auto.
Γ1, Δ: ctx ty
y: ty
f: Γ1 ⊆ Δ
v: val Γ1 y
a: ty
v0: var a Γ1
(r_shift1 f ᵣ⊛ ₁[ v ᵥ⊛ᵣ f])%asgn a (pop v0) =
(₁[ v] ⊛ᵣ f)%asgn a (pop v0)
  cbn; now rewrite v_ren_id_r.
Qed.

Lemma v_sub1_sub {Γ Δ A B} (f : Γ =[val]> Δ) (v : val Γ A) (w : val (Γ ▶ₓ A) B)
  : (w ᵥ⊛ a_shift1 f) ᵥ⊛ ₁[ v ᵥ⊛ f ] = (w ᵥ⊛ ₁[ v ]) ᵥ⊛ f .
Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
v: val Γ A
w: val (Γ ▶ₓ A) B
(w ᵥ⊛ a_shift1 f) ᵥ⊛ ₁[ v ᵥ⊛ f] = (w ᵥ⊛ ₁[ v]) ᵥ⊛ f
  cbn; rewrite 2 v_sub_sub.
Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
v: val Γ A
w: val (Γ ▶ₓ A) B
w ᵥ⊛ a_shift1 f ⊛ ₁[ v_subst Γ A v Δ f] =
w ᵥ⊛ ₁[ v] ⊛ f
  apply v_sub_eq; now rewrite sub1_sub.
Qed.

Lemma v_sub1_ren {Γ Δ A B} (f : Γ ⊆ Δ) (v : val Γ A) (w : val (Γ ▶ₓ A) B)
  : (w ᵥ⊛ᵣ r_shift1 f) ᵥ⊛ ₁[ v ᵥ⊛ᵣ f ] = (w ᵥ⊛ ₁[ v ]) ᵥ⊛ᵣ f .
Γ, Δ: ctx ty
A, B: ty
f: Γ ⊆ Δ
v: val Γ A
w: val (Γ ▶ₓ A) B
w ᵥ⊛ᵣ r_shift1 f ᵥ⊛ ₁[ v ᵥ⊛ᵣ f] = (w ᵥ⊛ ₁[ v]) ᵥ⊛ᵣ f
  cbn; rewrite v_sub_ren, v_ren_sub.
Γ, Δ: ctx ty
A, B: ty
f: Γ ⊆ Δ
v: val Γ A
w: val (Γ ▶ₓ A) B
w ᵥ⊛ r_shift1 f ᵣ⊛ ₁[ v ᵥ⊛ᵣ f] = w ᵥ⊛ ₁[ v] ⊛ᵣ f
  apply v_sub_eq; now rewrite sub1_ren.
Qed.

Lemma s_sub1_sub {Γ Δ A} (f : Γ =[val]> Δ) (v : val Γ A) (s : state (Γ ▶ₓ A))
  : (s ₜ⊛ a_shift1 f) ₜ⊛ ₁[ v ᵥ⊛ f ] = (s ₜ⊛ ₁[ v ]) ₜ⊛ f .
Γ, Δ: t_ctx
A: ty
f: Γ =[ val ]> Δ
v: val Γ A
s: state (Γ ▶ₓ A)
(s ₜ⊛ a_shift1 f) ₜ⊛ ₁[ v ᵥ⊛ f] = (s ₜ⊛ ₁[ v]) ₜ⊛ f
  cbn; now rewrite 2 s_sub_sub, sub1_sub.
Qed.

Lemma s_sub3_sub {Γ Δ A B C} (f : Γ =[val]> Δ) (s : state (Γ ▶ₓ A ▶ₓ B ▶ₓ C)) u v w
  : (s ₜ⊛ a_shift3 f) ₜ⊛ ₃[ u ᵥ⊛ f , v ᵥ⊛ f , w ᵥ⊛ f ] = (s ₜ⊛ ₃[ u, v , w ]) ₜ⊛ f .
Γ, Δ: t_ctx
A, B, C: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B ▶ₓ C)
u: val Γ A
v: val Γ B
w: val Γ C
(s ₜ⊛ a_shift3 f) ₜ⊛ ₃[ u ᵥ⊛ f, v ᵥ⊛ f, w ᵥ⊛ f] =
(s ₜ⊛ ₃[ u, v, w]) ₜ⊛ f
  cbn; rewrite 2 s_sub_sub; apply s_sub_eq.
Γ, Δ: t_ctx
A, B, C: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B ▶ₓ C)
u: val Γ A
v: val Γ B
w: val Γ C
a_shift3 f
⊛ ₃[ v_subst Γ A u Δ f, v_subst Γ B v Δ f,
  v_subst Γ C w Δ f] ≡ₐ ₃[ u, v, w] ⊛ f
  intros ? v0; cbn.
Γ, Δ: t_ctx
A, B, C: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B ▶ₓ C)
u: val Γ A
v: val Γ B
w: val Γ C
a: ty
v0: Γ ▶ₓ A ▶ₓ B ▶ₓ C ∋ a
v_subst (Δ ▶ₓ A ▶ₓ B ▶ₓ C) a (a_shift3 f a v0) Δ
  ₃[ v_subst Γ A u Δ f, v_subst Γ B v Δ f,
  v_subst Γ C w Δ f] =
v_subst Γ a (₃[ u, v, w] a v0) Δ f
  do 3 (dependent elimination v0; cbn; [ now rewrite v_sub_id_r | ]).
Γ1: ctx ty
Δ: t_ctx
y1, y0, y: ty
f: Γ1 =[ val ]> Δ
s: state (Γ1 ▶ₓ y1 ▶ₓ y0 ▶ₓ y)
u: val Γ1 y1
v: val Γ1 y0
w: val Γ1 y
a: ty
v0: var a Γ1
v_subst (Δ ▶ₓ y1 ▶ₓ y0 ▶ₓ y) a (v_shift3 a (f a v0)) Δ
  ₃[ v_subst Γ1 y1 u Δ f, v_subst Γ1 y0 v Δ f,
  v_subst Γ1 y w Δ f] = v_subst Γ1 a (Var v0) Δ f
  unfold v_shift3; rewrite v_sub_ren, v_sub_id_r, <- v_sub_id_l.
Γ1: ctx ty
Δ: t_ctx
y1, y0, y: ty
f: Γ1 =[ val ]> Δ
s: state (Γ1 ▶ₓ y1 ▶ₓ y0 ▶ₓ y)
u: val Γ1 y1
v: val Γ1 y0
w: val Γ1 y
a: ty
v0: var a Γ1
f a v0
ᵥ⊛ ((r_pop ᵣ⊛ r_pop) ᵣ⊛ r_pop)
   ᵣ⊛ ₃[ v_subst Γ1 y1 u Δ f, v_subst Γ1 y0 v Δ f,
      v_subst Γ1 y w Δ f] = f a v0 ᵥ⊛ Var
  now apply v_sub_eq.
Qed.

Lemma s_sub1_ren {Γ Δ A} (f : Γ ⊆ Δ) (v : val Γ A) (s : state (Γ ▶ₓ A))
  : (s ₛ⊛ᵣ r_shift1 f) ₜ⊛ ₁[ v ᵥ⊛ᵣ f ] = (s ₜ⊛ ₁[ v ]) ₛ⊛ᵣ f .
Γ, Δ: ctx ty
A: ty
f: Γ ⊆ Δ
v: val Γ A
s: state (Γ ▶ₓ A)
s ₛ⊛ᵣ r_shift1 f ₜ⊛ ₁[ v ᵥ⊛ᵣ f] = (s ₜ⊛ ₁[ v]) ₛ⊛ᵣ f
  cbn; now rewrite s_sub_ren, s_ren_sub, sub1_ren.
Qed.

Lemma t_sub1_sub {Γ Δ A B} (f : Γ =[val]> Δ) (v : val Γ A) (t : term (Γ ▶ₓ A) B)
  : (t `ₜ⊛ a_shift1 f) `ₜ⊛ ₁[ v ᵥ⊛ f ] = (t `ₜ⊛ ₁[ v ]) `ₜ⊛ f .
Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
v: val Γ A
t: term (Γ ▶ₓ A) B
(t `ₜ⊛ a_shift1 f) `ₜ⊛ ₁[ v ᵥ⊛ f] =
(t `ₜ⊛ ₁[ v]) `ₜ⊛ f
  cbn; rewrite 2 t_sub_sub.
Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
v: val Γ A
t: term (Γ ▶ₓ A) B
t `ₜ⊛ a_shift1 f ⊛ ₁[ v_subst Γ A v Δ f] =
t `ₜ⊛ ₁[ v] ⊛ f
  apply t_sub_eq; now rewrite sub1_sub.
Qed.

Lemma t_sub1_ren {Γ Δ A B} (f : Γ ⊆ Δ) (v : val Γ A) (t : term (Γ ▶ₓ A) B)
  : (t ₜ⊛ᵣ r_shift1 f) `ₜ⊛ ₁[ v ᵥ⊛ᵣ f ] = (t `ₜ⊛ ₁[ v ]) ₜ⊛ᵣ f .
Γ, Δ: ctx ty
A, B: ty
f: Γ ⊆ Δ
v: val Γ A
t: term (Γ ▶ₓ A) B
t ₜ⊛ᵣ r_shift1 f `ₜ⊛ ₁[ v ᵥ⊛ᵣ f] = (t `ₜ⊛ ₁[ v]) ₜ⊛ᵣ f
  cbn; rewrite t_sub_ren, t_ren_sub.
Γ, Δ: ctx ty
A, B: ty
f: Γ ⊆ Δ
v: val Γ A
t: term (Γ ▶ₓ A) B
t `ₜ⊛ r_shift1 f ᵣ⊛ ₁[ v ᵥ⊛ᵣ f] = t `ₜ⊛ ₁[ v] ⊛ᵣ f
  apply t_sub_eq; now rewrite sub1_ren.
Qed.

#[global] Instance p_app_eq {Γ A} (v : val Γ A) (m : pat (t_neg A))
  : Proper (asgn_eq _ _ ==> eq) (p_app v m) .
Γ: t_ctx
A: ty
v: val Γ A
m: pat A †
Proper (asgn_eq (pat_dom m) Γ ==> eq) (p_app v m)
  intros u1 u2 H; destruct A; cbn.
Γ: t_ctx
p: pre_ty
v: val Γ ↑ p
m: pat (↑ p) †
u1, u2: pat_dom m =[ val ]> Γ
H: u1 ≡ₐ u2
Cut (Val v) (m `ₜ⊛ u1) = Cut (Val v) (m `ₜ⊛ u2)
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
m: pat (¬ p) †
u1, u2: pat_dom m =[ val ]> Γ
H: u1 ≡ₐ u2
Cut (Val (m `ᵥ⊛ u1)) v = Cut (Val (m `ᵥ⊛ u2)) v
  now rewrite (t_sub_eq u1 u2 H).
Γ: t_ctx
p: pre_ty
v: val Γ ¬ p
m: pat (¬ p) †
u1, u2: pat_dom m =[ val ]> Γ
H: u1 ≡ₐ u2
Cut (Val (m `ᵥ⊛ u1)) v = Cut (Val (m `ᵥ⊛ u2)) v
  now rewrite (w_sub_eq u1 u2 H).
Qed.

Lemma refold_id_aux {Γ : neg_ctx} A (v : whn Γ A)
  : (p_of_w _ v : val _ _) `ᵥ⊛ p_dom_of_w _ v = v .
Γ: neg_ctx
A: pre_ty
v: whn Γ A
(p_of_w A v : val (pat_dom (p_of_w A v)) ↑ A)
`ᵥ⊛ p_dom_of_w A v = v
  cbn; funelim (p_of_w A v); auto.
Γ: neg_ctx
i: Γ ∋ ↑ `0
p_of_w `0 (VarL i) `ᵥ⊛ p_dom_of_w `0 (VarL i) = VarL i
Γ: neg_ctx
a, b: pre_ty
i: Γ ∋ ↑ (a `+ b)
p_of_w (a `+ b) (VarL i)
`ᵥ⊛ p_dom_of_w (a `+ b) (VarL i) = VarL i
Γ: neg_ctx
a, b: pre_ty
v: whn Γ a
H: p_of_w a v `ᵥ⊛ p_dom_of_w a v = v
Heqcall: PInl (p_of_w a v) = p_of_w (a `+ b) (Inl v)
p_of_w (a `+ b) (Inl v)
`ᵥ⊛ p_dom_of_w (a `+ b) (Inl v) = Inl v
Γ: neg_ctx
a, b: pre_ty
v: whn Γ b
H: p_of_w b v `ᵥ⊛ p_dom_of_w b v = v
Heqcall: PInr (p_of_w b v) = p_of_w (a `+ b) (Inr v)
p_of_w (a `+ b) (Inr v)
`ᵥ⊛ p_dom_of_w (a `+ b) (Inr v) = 
Inr v
  -
Γ: neg_ctx
i: Γ ∋ ↑ `0
p_of_w `0 (VarL i) `ᵥ⊛ p_dom_of_w `0 (VarL i) = VarL i destruct (s_prf i).
  -
Γ: neg_ctx
a, b: pre_ty
i: Γ ∋ ↑ (a `+ b)
p_of_w (a `+ b) (VarL i)
`ᵥ⊛ p_dom_of_w (a `+ b) (VarL i) = VarL i destruct (s_prf i).
  -
Γ: neg_ctx
a, b: pre_ty
v: whn Γ a
H: p_of_w a v `ᵥ⊛ p_dom_of_w a v = v
Heqcall: PInl (p_of_w a v) = p_of_w (a `+ b) (Inl v)
p_of_w (a `+ b) (Inl v)
`ᵥ⊛ p_dom_of_w (a `+ b) (Inl v) = Inl v now cbn; f_equal. 
  -
Γ: neg_ctx
a, b: pre_ty
v: whn Γ b
H: p_of_w b v `ᵥ⊛ p_dom_of_w b v = v
Heqcall: PInr (p_of_w b v) = p_of_w (a `+ b) (Inr v)
p_of_w (a `+ b) (Inr v)
`ᵥ⊛ p_dom_of_w (a `+ b) (Inr v) = Inr v now cbn; f_equal. 
Qed.

Equations p_of_w_eq {Γ : neg_ctx} A (p : pat ↑A) (e : pat_dom p =[val]> Γ)
          : p_of_w A ((p : val _ _) `ᵥ⊛ e) = p :=
  p_of_w_eq (a `+ b) (PInl v) e := f_equal PInl (p_of_w_eq _ v e) ;
  p_of_w_eq (a `+ b) (PInr v) e := f_equal PInr (p_of_w_eq _ v e) ;
  p_of_w_eq (`1)     PTt      e := eq_refl ;
  p_of_w_eq (a `× b) PPair    e := eq_refl ;
  p_of_w_eq (a `→ b) PLam     e := eq_refl .

Lemma p_dom_of_w_eq {Γ : neg_ctx} A (p : pat ↑A) (e : pat_dom p =[val]> Γ)
      : rew [fun p => pat_dom p =[ val ]> Γ] p_of_w_eq A p e
        in p_dom_of_w A ((p : val _ _) `ᵥ⊛ e)
      ≡ₐ e .
Γ: neg_ctx
A: pre_ty
p: pat ↑ A
e: pat_dom p =[ val ]> Γ
rew [fun p : pat ↑ A => pat_dom p =[ val ]> Γ]
    p_of_w_eq A p e in
p_dom_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ e) ≡ₐ e
  funelim (p_of_w_eq A p e); cbn.
Γ: neg_ctx
e: pat_dom PTt =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq `1 PTt e
! ▶ₐ e ↑ `1 top ≡ₐ e
Γ: neg_ctx
a, b: pre_ty
e: pat_dom PPair =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq (a `× b) PPair e
! ▶ₐ e ↑ (a `× b) top ≡ₐ e
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ a
e: pat_dom (PInl v) =[ val ]> Γ
H: rew [fun p : pat ↑ a => pat_dom p =[ val ]> Γ]
    p_of_w_eq a v e in 
p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e
rew [fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ]
    f_equal PInl (p_of_w_eq a v e) in
p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ b
e: pat_dom (PInr v) =[ val ]> Γ
H: rew [fun p : pat ↑ b => pat_dom p =[ val ]> Γ]
    p_of_w_eq b v e in 
p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e
rew [fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ]
    f_equal PInr (p_of_w_eq b v e) in
p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
a, b: pre_ty
e: pat_dom PLam =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq (a `→ b) PLam e
! ▶ₐ e ↑ (a `→ b) top ≡ₐ e
  -
Γ: neg_ctx
e: pat_dom PTt =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq `1 PTt e
! ▶ₐ e ↑ `1 top ≡ₐ e intros ? v; repeat (dependent elimination v; auto).
  -
Γ: neg_ctx
a, b: pre_ty
e: pat_dom PPair =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq (a `× b) PPair e
! ▶ₐ e ↑ (a `× b) top ≡ₐ e intros ? v; repeat (dependent elimination v; auto).
  -
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ a
e: pat_dom (PInl v) =[ val ]> Γ
H: rew [fun p : pat ↑ a => pat_dom p =[ val ]> Γ]
    p_of_w_eq a v e in p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e
rew [fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ]
    f_equal PInl (p_of_w_eq a v e) in
p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ a
e: pat_dom (PInl v) =[ val ]> Γ
H: rew [fun p : pat ↑ a => pat_dom p =[ val ]> Γ]
    p_of_w_eq a v e in p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e
xx:= rew [fun p : pat ↑ (a `+ b) =>
     pat_dom p =[ val ]> Γ]
    f_equal PInl (p_of_w_eq a v e) in
p_dom_of_w a (v `ᵥ⊛ e): (fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ)
  (PInl v)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ a
e: pat_dom (PInl v) =[ val ]> Γ
H: rew [fun p : pat ↑ a => pat_dom p =[ val ]> Γ]
    p_of_w_eq a v e in p_dom_of_w a (v `ᵥ⊛ e) ≡ₐ e
xx': (fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ) (PInl v)
Heqxx': xx' =
rew [fun p : pat ↑ (a `+ b) =>
     pat_dom p =[ val ]> Γ]
    f_equal PInl (p_of_w_eq a v e) in
p_dom_of_w a (v `ᵥ⊛ e)
xx' ≡ₐ e
    now rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PInl _ _))).
  -
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ b
e: pat_dom (PInr v) =[ val ]> Γ
H: rew [fun p : pat ↑ b => pat_dom p =[ val ]> Γ]
    p_of_w_eq b v e in p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e
rew [fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ]
    f_equal PInr (p_of_w_eq b v e) in
p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ b
e: pat_dom (PInr v) =[ val ]> Γ
H: rew [fun p : pat ↑ b => pat_dom p =[ val ]> Γ]
    p_of_w_eq b v e in p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e
xx:= rew [fun p : pat ↑ (a `+ b) =>
     pat_dom p =[ val ]> Γ]
    f_equal PInr (p_of_w_eq b v e) in
p_dom_of_w b (v `ᵥ⊛ e): (fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ)
  (PInr v)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.
Γ: neg_ctx
a, b: pre_ty
v: pat ↑ b
e: pat_dom (PInr v) =[ val ]> Γ
H: rew [fun p : pat ↑ b => pat_dom p =[ val ]> Γ]
    p_of_w_eq b v e in p_dom_of_w b (v `ᵥ⊛ e) ≡ₐ e
xx': (fun p : pat ↑ (a `+ b) => pat_dom p =[ val ]> Γ) (PInr v)
Heqxx': xx' =
rew [fun p : pat ↑ (a `+ b) =>
     pat_dom p =[ val ]> Γ]
    f_equal PInr (p_of_w_eq b v e) in
p_dom_of_w b (v `ᵥ⊛ e)
xx' ≡ₐ e
    now rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PInr _ _))).
  -
Γ: neg_ctx
a, b: pre_ty
e: pat_dom PLam =[ val ]> Γ
Heqcall: eq_refl = p_of_w_eq (a `→ b) PLam e
! ▶ₐ e ↑ (a `→ b) top ≡ₐ e intros ? v; repeat (dependent elimination v; auto).
Qed.

Notation val_n := (val ∘ neg_c_coe).
Notation state_n := (state ∘ neg_c_coe).

#[global] Instance val_n_monoid : subst_monoid val_n .
subst_monoid val_n
  esplit.
c_var ⇒₁ val_n
val_n ⇒₁ (⟦ val_n, val_n ⟧₁)
  -
c_var ⇒₁ val_n intros Γ x i; exact (Var i).
  -
val_n ⇒₁ (⟦ val_n, val_n ⟧₁) intros Γ x v Δ f; exact (v ᵥ⊛ f).
Defined.

#[global] Instance state_n_module : subst_module val_n state_n .
subst_module val_n state_n
  esplit; intros Γ s Δ f; exact (s ₜ⊛ (f : Γ =[val]> Δ)).
Defined.

#[global] Instance val_n_laws : subst_monoid_laws val_n .
subst_monoid_laws val_n
  esplit.
Proper
  (∀ₕ Γ, (∀ₕ a, eq ==> (∀ₕ Δ, asgn_eq Γ Δ ==> eq)))
  v_sub
forall (Γ1 Γ2 : neg_ctx) (x : ty) (i : Γ1 ∋ x)
  (p : Γ1 =[ val_n ]> Γ2), a_id i ᵥ⊛ p = p x i
forall (Γ : neg_ctx) (x : ty) (v : val Γ x),
v ᵥ⊛ a_id = v
forall (Γ1 Γ2 Γ3 : neg_ctx) (x : ty) (v : val Γ1 x)
  (a : Γ1 =[ val_n ]> Γ2) (b : Γ2 =[ val_n ]> Γ3),
v ᵥ⊛ a ⊛ b = (v ᵥ⊛ a) ᵥ⊛ b
  -
Proper
  (∀ₕ Γ, (∀ₕ a, eq ==> (∀ₕ Δ, asgn_eq Γ Δ ==> eq)))
  v_sub intros ???? <- ????; now apply v_sub_eq.
  -
forall (Γ1 Γ2 : neg_ctx) (x : ty) (i : Γ1 ∋ x)
  (p : Γ1 =[ val_n ]> Γ2), a_id i ᵥ⊛ p = p x i intros ?????; now apply v_sub_id_r.
  -
forall (Γ : neg_ctx) (x : ty) (v : val Γ x),
v ᵥ⊛ a_id = v intros ???; now apply v_sub_id_l.
  -
forall (Γ1 Γ2 Γ3 : neg_ctx) (x : ty) (v : val Γ1 x)
  (a : Γ1 =[ val_n ]> Γ2) (b : Γ2 =[ val_n ]> Γ3),
v ᵥ⊛ a ⊛ b = (v ᵥ⊛ a) ᵥ⊛ b intros ???????; symmetry; now apply v_sub_sub.
Qed.

#[global] Instance state_n_laws : subst_module_laws val_n state_n .
subst_module_laws val_n state_n
  esplit.
Proper (∀ₕ Γ, eq ==> (∀ₕ Δ, asgn_eq Γ Δ ==> eq)) c_sub
forall (Γ : neg_ctx) (c : state Γ), c ₜ⊛ a_id = c
forall (Γ1 Γ2 Γ3 : neg_ctx) (c : state Γ1)
  (a : Γ1 =[ val_n ]> Γ2) (b : Γ2 =[ val_n ]> Γ3),
c ₜ⊛ a ⊛ b = (c ₜ⊛ a) ₜ⊛ b
  -
Proper (∀ₕ Γ, eq ==> (∀ₕ Δ, asgn_eq Γ Δ ==> eq)) c_sub intros ??? <- ????; now apply s_sub_eq.
  -
forall (Γ : neg_ctx) (c : state Γ), c ₜ⊛ a_id = c intros ??; now apply s_sub_id_l.
  -
forall (Γ1 Γ2 Γ3 : neg_ctx) (c : state Γ1)
  (a : Γ1 =[ val_n ]> Γ2) (b : Γ2 =[ val_n ]> Γ3),
c ₜ⊛ a ⊛ b = (c ₜ⊛ a) ₜ⊛ b intros ??????; symmetry; now apply s_sub_sub.
Qed.

#[global] Instance var_laws : var_assumptions val_n.
var_assumptions val_n
  esplit.
forall (Γ : neg_ctx) (x : ty), injective (a_id (x:=x))
forall (Γ : neg_ctx) (x : ty) (v : val Γ x),
decidable (is_var v)
forall (Γ1 Γ2 : neg_ctx) (x : ty) (v : val Γ1 x)
  (r : Γ1 ⊆ Γ2), is_var (v_ren v r) -> is_var v
  -
forall (Γ : neg_ctx) (x : ty), injective (a_id (x:=x)) intros ? [] ?? H; now dependent destruction H.
  -
forall (Γ : neg_ctx) (x : ty) (v : val Γ x),
decidable (is_var v) intros ? [] v; dependent elimination v.
Γ: neg_ctx
A: pre_ty
c: Γ ∋ ↑ A
decidable (is_var (VarL c))
Γ: neg_ctx
A0, B: pre_ty
w: whn Γ A0
decidable (is_var (Inl w))
Γ: neg_ctx
A1, B0: pre_ty
w0: whn Γ B0
decidable (is_var (Inr w0))
Γ: neg_ctx
decidable (is_var Tt)
Γ: neg_ctx
A2, B1: pre_ty
s: state (Γ ▶ₓ ¬ A2)
s0: state (Γ ▶ₓ ¬ B1)
decidable (is_var (Pair s s0))
Γ: neg_ctx
A3, B2: pre_ty
s1: state (Γ ▶ₓ ↑ (A3 `→ B2) ▶ₓ ↑ A3 ▶ₓ ¬ B2)
decidable (is_var (Lam s1))
Γ: neg_ctx
A1: pre_ty
c: Γ ∋ ¬ A1
decidable (is_var (VarR c))
Γ: neg_ctx
A2: pre_ty
s0: state (Γ ▶ₓ ↑ A2)
decidable (is_var (MuT s0))
Γ: neg_ctx
decidable (is_var Boom)
Γ: neg_ctx
A3, B: pre_ty
s1: state (Γ ▶ₓ ↑ A3)
s2: state (Γ ▶ₓ ↑ B)
decidable (is_var (Case s1 s2))
Γ: neg_ctx
A4, B0: pre_ty
t: term Γ ¬ A4
decidable (is_var (Fst t))
Γ: neg_ctx
A5, B1: pre_ty
t0: term Γ ¬ B1
decidable (is_var (Snd t0))
Γ: neg_ctx
A6, B2: pre_ty
w0: whn Γ A6
t1: term Γ ¬ B2
decidable (is_var (App w0 t1))
    all: try exact (Yes _ (Vvar _)).
Γ: neg_ctx
A0, B: pre_ty
w: whn Γ A0
decidable (is_var (Inl w))
Γ: neg_ctx
A1, B0: pre_ty
w0: whn Γ B0
decidable (is_var (Inr w0))
Γ: neg_ctx
decidable (is_var Tt)
Γ: neg_ctx
A2, B1: pre_ty
s: state (Γ ▶ₓ ¬ A2)
s0: state (Γ ▶ₓ ¬ B1)
decidable (is_var (Pair s s0))
Γ: neg_ctx
A3, B2: pre_ty
s1: state (Γ ▶ₓ ↑ (A3 `→ B2) ▶ₓ ↑ A3 ▶ₓ ¬ B2)
decidable (is_var (Lam s1))
Γ: neg_ctx
A2: pre_ty
s0: state (Γ ▶ₓ ↑ A2)
decidable (is_var (MuT s0))
Γ: neg_ctx
decidable (is_var Boom)
Γ: neg_ctx
A3, B: pre_ty
s1: state (Γ ▶ₓ ↑ A3)
s2: state (Γ ▶ₓ ↑ B)
decidable (is_var (Case s1 s2))
Γ: neg_ctx
A4, B0: pre_ty
t: term Γ ¬ A4
decidable (is_var (Fst t))
Γ: neg_ctx
A5, B1: pre_ty
t0: term Γ ¬ B1
decidable (is_var (Snd t0))
Γ: neg_ctx
A6, B2: pre_ty
w0: whn Γ A6
t1: term Γ ¬ B2
decidable (is_var (App w0 t1))
    all: apply No; intro H; dependent destruction H.
  -
forall (Γ1 Γ2 : neg_ctx) (x : ty) (v : val Γ1 x)
  (r : Γ1 ⊆ Γ2), is_var (v_ren v r) -> is_var v intros ?? [] ???; cbn in v; dependent induction v.
Γ2, Γ1: neg_ctx
A: pre_ty
c: Γ1 ∋ ↑ A
r: Γ1 ⊆ Γ2
X: is_var (v_ren (VarL c) r)
is_var (VarL c)
Γ2, Γ1: neg_ctx
A, B: pre_ty
v: whn Γ1 A
IHv: forall (Γ3 : neg_ctx) (v0 : whn Γ3 A),
Γ1 ~= Γ3 -> v ~= v0 -> forall r : Γ3 ⊆ Γ2, is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Inl v) r)
is_var (Inl v)
Γ2, Γ1: neg_ctx
A, B: pre_ty
v: whn Γ1 B
IHv: forall (Γ3 : neg_ctx) (v0 : whn Γ3 B),
Γ1 ~= Γ3 -> v ~= v0 -> forall r : Γ3 ⊆ Γ2, is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Inr v) r)
is_var (Inr v)
Γ2, Γ1: neg_ctx
r: Γ1 ⊆ Γ2
X: is_var (v_ren Tt r)
is_var Tt
Γ2, Γ1: neg_ctx
A, B: pre_ty
s: state (Γ1 ▶ₓ ¬ A)
s0: state (Γ1 ▶ₓ ¬ B)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Pair s s0) r)
is_var (Pair s s0)
Γ2, Γ1: neg_ctx
A, B: pre_ty
s: state (Γ1 ▶ₓ ↑ (A `→ B) ▶ₓ ↑ A ▶ₓ ¬ B)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Lam s) r)
is_var (Lam s)
Γ2, Γ1: neg_ctx
p: pre_ty
c: Γ1 ∋ ¬ p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (VarR c) r)
is_var (VarR c)
Γ2, Γ1: neg_ctx
p: pre_ty
s: state (Γ1 ▶ₓ ↑ p)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (MuT s) r)
is_var (MuT s)
Γ2, Γ1: neg_ctx
r: Γ1 ⊆ Γ2
X: is_var (v_ren Boom r)
is_var Boom
Γ2, Γ1: neg_ctx
A, B: pre_ty
s: state (Γ1 ▶ₓ ↑ A)
s0: state (Γ1 ▶ₓ ↑ B)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Case s s0) r)
is_var (Case s s0)
Γ2, Γ1: neg_ctx
A, B: pre_ty
v: term Γ1 ¬ A
IHv: forall (Γ3 : neg_ctx) (p : pre_ty) (v0 : term Γ3 ¬ p),
Γ1 ~= Γ3 ->
¬ A = ¬ p -> v ~= v0 -> forall r : Γ3 ⊆ Γ2, is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Fst v) r)
is_var (Fst v)
Γ2, Γ1: neg_ctx
A, B: pre_ty
v: term Γ1 ¬ B
IHv: forall (Γ3 : neg_ctx) (p : pre_ty) (v0 : term Γ3 ¬ p),
Γ1 ~= Γ3 ->
¬ B = ¬ p -> v ~= v0 -> forall r : Γ3 ⊆ Γ2, is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Snd v) r)
is_var (Snd v)
Γ2, Γ1: neg_ctx
A, B: pre_ty
w: whn Γ1 A
v: term Γ1 ¬ B
IHv: forall (Γ3 : neg_ctx) (p : pre_ty) (v0 : term Γ3 ¬ p),
Γ1 ~= Γ3 ->
¬ B = ¬ p -> v ~= v0 -> forall r : Γ3 ⊆ Γ2, is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (App w v) r)
is_var (App w v)
    all: try now dependent destruction X; exact (Vvar _).
    all: dependent induction w; dependent destruction X; exact (Vvar _).
Qed.

#[global] Instance sysl_machine : machine val_n state_n op_copat :=
  {| Machine.eval := @eval ; oapp := @p_app |} .

From Coinduction Require Import coinduction lattice rel tactics.

Ltac refold_eval :=
  change (Structure.iter _ _ ?a) with (eval a);
  change (Structure.subst (fun pat : T1 => let 'T1_0 := pat in ?f) T1_0 ?u)
    with (bind_delay' u f).

Definition upg_v {Γ} {A : pre_ty} : whn Γ A  -> val Γ ↑A := fun v => v.
Definition upg_k {Γ} {A : pre_ty} : term Γ ¬A -> val Γ ¬A := fun v => v.
Definition dwn_v {Γ} {A : pre_ty} : val Γ ↑A -> whn Γ A  := fun v => v.
Definition dwn_k {Γ} {A : pre_ty} : val Γ ¬A -> term Γ ¬A := fun v => v.

Lemma nf_eq_split {Γ : neg_ctx} {A : pre_ty} (i : Γ ∋ ¬A) (p : pat ↑A) γ
  : nf_eq (i ⋅ w_split _ (dwn_v ((p : val _ _) `ᵥ⊛ γ)))
          (i ⋅ (p : o_op op_copat ¬A) ⦇ γ ⦈).
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
nf_eq
  (i
   ⋅ w_split A
       (dwn_v ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ)))
  (i ⋅ (p : op_copat ¬ A) ⦇ γ ⦈)
  unfold w_split, dwn_v; cbn.
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
nf_eq
  (i ⋅ p_of_w A (p `ᵥ⊛ γ) ⦇ p_dom_of_w A (p `ᵥ⊛ γ) ⦈)
  (i ⋅ p ⦇ γ ⦈)
  pose proof (p_dom_of_w_eq A p γ).
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
H: rew [fun p : pat ↑ A => pat_dom p =[ val ]> Γ]
    p_of_w_eq A p γ in
p_dom_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ)
≡ₐ γ
nf_eq
  (i ⋅ p_of_w A (p `ᵥ⊛ γ) ⦇ p_dom_of_w A (p `ᵥ⊛ γ) ⦈)
  (i ⋅ p ⦇ γ ⦈)
  pose (H' := p_of_w_eq A p γ); fold H' in H.
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
H':= p_of_w_eq A p γ: p_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ) = p
H: rew [fun p : pat ↑ A => pat_dom p =[ val ]> Γ]
    H' in
p_dom_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ)
≡ₐ γ
nf_eq
  (i ⋅ p_of_w A (p `ᵥ⊛ γ) ⦇ p_dom_of_w A (p `ᵥ⊛ γ) ⦈)
  (i ⋅ p ⦇ γ ⦈)
  pose (a := p_dom_of_w A (v_of_p p `ᵥ⊛ γ)); fold a in H |- *.
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
H':= p_of_w_eq A p γ: p_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ) = p
a:= p_dom_of_w A (p `ᵥ⊛ γ): pat_dom (p_of_w A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat ↑ A => pat_dom p =[ val ]> Γ]
    H' in a ≡ₐ γ
nf_eq (i ⋅ p_of_w A (p `ᵥ⊛ γ) ⦇ a ⦈) (i ⋅ p ⦇ γ ⦈)
  remember a as a'; clear a Heqa'.
Γ: neg_ctx
A: pre_ty
i: Γ ∋ ¬ A
p: pat ↑ A
γ: pat_dom p =[ val ]> Γ
H':= p_of_w_eq A p γ: p_of_w A ((p : val (pat_dom p) ↑ A) `ᵥ⊛ γ) = p
a': pat_dom (p_of_w A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat ↑ A => pat_dom p =[ val ]> Γ]
    H' in a' ≡ₐ γ
nf_eq (i ⋅ p_of_w A (p `ᵥ⊛ γ) ⦇ a' ⦈) (i ⋅ p ⦇ γ ⦈)
  revert a' H; rewrite H'; intros; now econstructor.
Qed.

#[global] Instance machine_law : machine_laws val_n state_n op_copat.
machine_laws val_n state_n op_copat
  esplit.
forall (Γ : neg_ctx) (x : ty) (v : val Γ x)
  (o : op_copat x),
Proper (asgn_eq (dom o) Γ ==> eq) (oapp v o)
forall (Γ1 Γ2 : neg_ctx) (x : ty) (v : val Γ1 x)
  (o : op_copat x) (a : dom o =[ val_n ]> Γ1)
  (b : Γ1 =[ val_n ]> Γ2),
v ⊙ o ⦗ a ⦘ ₜ⊛ b = (v ᵥ⊛ b) ⊙ o ⦗ a ⊛ b ⦘
forall (Γ Δ : neg_ctx) (c : state Γ)
  (a : Γ =[ val_n ]> Δ),
Machine.eval (c ₜ⊛ a)
≋ bind_delay' (Machine.eval c)
    (fun n : nf op_copat val_n Γ =>
     Machine.eval (emb n ₜ⊛ a))
forall (Γ : neg_ctx) (u : nf op_copat val_n Γ),
Machine.eval (emb u) ≋ ret_delay u
well_founded head_inst_nostep
  -
forall (Γ : neg_ctx) (x : ty) (v : val Γ x)
  (o : op_copat x),
Proper (asgn_eq (dom o) Γ ==> eq) (oapp v o) intros; apply p_app_eq.
  -
forall (Γ1 Γ2 : neg_ctx) (x : ty) (v : val Γ1 x)
  (o : op_copat x) (a : dom o =[ val_n ]> Γ1)
  (b : Γ1 =[ val_n ]> Γ2),
v ⊙ o ⦗ a ⦘ ₜ⊛ b = (v ᵥ⊛ b) ⊙ o ⦗ a ⊛ b ⦘ intros ?? [] ????; cbn.
Γ1, Γ2: neg_ctx
p: pre_ty
v: val Γ1 ↑ p
o: op_copat ↑ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut (Val (v `ᵥ⊛ b)) ((o `ₜ⊛ a) `ₜ⊛ b) =
Cut (Val (v `ᵥ⊛ b)) (o `ₜ⊛ a ⊛ b)
Γ1, Γ2: neg_ctx
p: pre_ty
v: val Γ1 ¬ p
o: op_copat ¬ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut (Val ((o `ᵥ⊛ a) `ᵥ⊛ b)) (v `ₜ⊛ b) =
Cut (Val (o `ᵥ⊛ a ⊛ b)) (v `ₜ⊛ b)
    now rewrite (t_sub_sub _ _ _ _).
Γ1, Γ2: neg_ctx
p: pre_ty
v: val Γ1 ¬ p
o: op_copat ¬ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut (Val ((o `ᵥ⊛ a) `ᵥ⊛ b)) (v `ₜ⊛ b) =
Cut (Val (o `ᵥ⊛ a ⊛ b)) (v `ₜ⊛ b)
    now rewrite (w_sub_sub _ _ _ _).
  -
forall (Γ Δ : neg_ctx) (c : state Γ)
  (a : Γ =[ val_n ]> Δ),
Machine.eval (c ₜ⊛ a)
≋ bind_delay' (Machine.eval c)
    (fun n : nf op_copat val_n Γ =>
     Machine.eval (emb n ₜ⊛ a)) cbn; intros Γ Δ; unfold comp_eq, it_eq; coinduction R CIH; intros c a.
Γ, Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
c: state Γ
a: Γ =[ val_n ]> Δ
it_eq_bt ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval (s_subst Γ c Δ a))
  (bind_delay' (eval c)
     (fun n : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var n)) (nf_obs n)
              (nf_args n)) Δ a)))
    cbn; funelim (eval_aux c); try now destruct (s_prf i).
Γ: neg_ctx
A2: pre_ty
v: whn Γ A2
i: Γ ∋ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux (s_subst Γ (Cut (Val v) (VarR i)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val v) (VarR i)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A3: pre_ty
v: whn Γ A3
s: state (Γ ▶ₓ ↑ A3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux (s_subst Γ (Cut (Val v) (MuT s)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val v) (MuT s)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A0, B0: pre_ty
u: whn Γ A0
s: state (Γ ▶ₓ ↑ A0)
t: state (Γ ▶ₓ ↑ B0)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Inl u)) (Case s t)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Inl u)) (Case s t)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A1, B1: pre_ty
u: whn Γ B1
s: state (Γ ▶ₓ ↑ A1)
t: state (Γ ▶ₓ ↑ B1)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Inr u)) (Case s t)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Inr u)) (Case s t)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A5, B0: pre_ty
i: Γ ∋ ↑ (A5 `× B0)
k: term Γ ¬ A5
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (Fst k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (Fst k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Pair s t)) (Fst k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Pair s t)) (Fst k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A6, B1: pre_ty
i: Γ ∋ ↑ (A6 `× B1)
k: term Γ ¬ B1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (Snd k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (Snd k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Pair s t)) (Snd k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Pair s t)) (Snd k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (App v k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Lam s)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Lam s)) (App v k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A1: pre_ty
s: state (Γ ▶ₓ ¬ A1)
k: term Γ ¬ A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match eval_aux (s_subst Γ (Cut (Mu s) k) Δ a) with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Mu s) k) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
    +
Γ: neg_ctx
A2: pre_ty
v: whn Γ A2
i: Γ ∋ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux (s_subst Γ (Cut (Val v) (VarR i)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val v) (VarR i)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end change (it_eqF _ ?RX ?RY _ _ _) with
        (it_eq_map ∅ₑ RX RY T1_0
           (eval (Cut (Val (v `ᵥ⊛ a)) (a _ i)))
           (eval (Cut (Val ((v_of_p (p_of_w _ v) `ᵥ⊛ p_dom_of_w _ v `ᵥ⊛ a))) (a _ i)))).
Γ: neg_ctx
A2: pre_ty
v: whn Γ A2
i: Γ ∋ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_map ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  (eval (Cut (Val (v `ᵥ⊛ a)) (a ¬ A2 i)))
  (eval
     (Cut
        (Val ((p_of_w A2 v `ᵥ⊛ p_dom_of_w A2 v) `ᵥ⊛ a))
        (a ¬ A2 i)))
      now rewrite (refold_id_aux _ v).
    +
Γ: neg_ctx
A3: pre_ty
v: whn Γ A3
s: state (Γ ▶ₓ ↑ A3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux (s_subst Γ (Cut (Val v) (MuT s)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val v) (MuT s)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A3: pre_ty
v: whn Γ A3
s: state (Γ ▶ₓ ↑ A3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ A3)
        (s_subst (Γ ▶ₓ ↑ A3) s (Δ ▶ₓ ↑ A3)
           (a_shift1 a)) Δ ₁[ v `ᵥ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ A3) s Γ ₁[ v]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_v v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A3: pre_ty
v: whn Γ A3
s: state (Γ ▶ₓ ↑ A3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((s ₜ⊛ ₁[ upg_v v]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ A3) s Γ ₁[ v]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A0, B0: pre_ty
u: whn Γ A0
s: state (Γ ▶ₓ ↑ A0)
t: state (Γ ▶ₓ ↑ B0)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Inl u)) (Case s t)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Inl u)) (Case s t)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A0, B0: pre_ty
u: whn Γ A0
s: state (Γ ▶ₓ ↑ A0)
t: state (Γ ▶ₓ ↑ B0)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ A0)
        (s_subst (Γ ▶ₓ ↑ A0) s (Δ ▶ₓ ↑ A0)
           (a_shift1 a)) Δ ₁[ u `ᵥ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ A0) s Γ ₁[ u]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_v v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A0, B0: pre_ty
u: whn Γ A0
s: state (Γ ▶ₓ ↑ A0)
t: state (Γ ▶ₓ ↑ B0)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((s ₜ⊛ ₁[ upg_v u]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ A0) s Γ ₁[ u]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A1, B1: pre_ty
u: whn Γ B1
s: state (Γ ▶ₓ ↑ A1)
t: state (Γ ▶ₓ ↑ B1)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Inr u)) (Case s t)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Inr u)) (Case s t)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A1, B1: pre_ty
u: whn Γ B1
s: state (Γ ▶ₓ ↑ A1)
t: state (Γ ▶ₓ ↑ B1)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ B1)
        (s_subst (Γ ▶ₓ ↑ B1) t (Δ ▶ₓ ↑ B1)
           (a_shift1 a)) Δ ₁[ u `ᵥ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ B1) t Γ ₁[ u]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_v v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A1, B1: pre_ty
u: whn Γ B1
s: state (Γ ▶ₓ ↑ A1)
t: state (Γ ▶ₓ ↑ B1)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((t ₜ⊛ ₁[ upg_v u]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ↑ B1) t Γ ₁[ u]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A5, B0: pre_ty
i: Γ ∋ ↑ (A5 `× B0)
k: term Γ ¬ A5
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (Fst k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (Fst k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end now change (it_eqF _ ?RX ?RY _ _ _) with
        (it_eq_map ∅ₑ RX RY T1_0
           (eval (Cut (a _ i) (Fst k `ₜ⊛ a)))
           (eval (Cut (a _ i) (Fst k `ₜ⊛ a)))).
    +
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Pair s t)) (Fst k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Pair s t)) (Fst k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ¬ A2)
        (s_subst (Γ ▶ₓ ¬ A2) s (Δ ▶ₓ ¬ A2)
           (a_shift1 a)) Δ ₁[ k `ₜ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ A2) s Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_k v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((s ₜ⊛ ₁[ upg_k k]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ A2) s Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A6, B1: pre_ty
i: Γ ∋ ↑ (A6 `× B1)
k: term Γ ¬ B1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (Snd k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (Snd k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end now change (it_eqF _ ?RX ?RY _ _ _) with
        (it_eq_map ∅ₑ RX RY T1_0
           (eval (Cut (a _ i) (Snd k `ₜ⊛ a)))
           (eval (Cut (a _ i) (Snd k `ₜ⊛ a)))).
    +
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Pair s t)) (Snd k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Pair s t)) (Snd k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ¬ B2)
        (s_subst (Γ ▶ₓ ¬ B2) t (Δ ▶ₓ ¬ B2)
           (a_shift1 a)) Δ ₁[ k `ₜ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ B2) t Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_k v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A2, B2: pre_ty
s: state (Γ ▶ₓ ¬ A2)
t: state (Γ ▶ₓ ¬ B2)
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((t ₜ⊛ ₁[ upg_k k]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ B2) t Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (VarL i)) (App v k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end simp eval_aux.
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    eval_aux
      (s_subst Γ
         (p_app (Var (nf_var (app_nf i v k)))
            (nf_obs (app_nf i v k))
            (nf_args (app_nf i v k))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
      unfold p_app, app_nf, nf_var, nf_obs, nf_args, cut_l, cut_r, fill_op, fill_args.
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (VarL i)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    eval_aux
      (s_subst Γ
         (Cut' (Var i)
            (PApp (p_of_w A7 v)
             `ₜ⊛ (p_dom_of_w A7 v ▶ₐ k))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
      change (it_eqF _ ?RX ?RY _ _ _) with
        (it_eq_map ∅ₑ RX RY T1_0
           (eval (Cut (a _ i) (App v k `ₜ⊛ a)))
           (eval (Cut (a _ i) (PApp (p_of_w A7 v) `ₜ⊛ [ p_dom_of_w _ v ,ₓ upg_k k ] `ₜ⊛ a)))).
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_map ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  (eval (Cut (a ↑ (A7 `→ B2) i) (App v k `ₜ⊛ a)))
  (eval
     (Cut (a ↑ (A7 `→ B2) i)
        ((PApp (p_of_w A7 v)
          `ₜ⊛ (p_dom_of_w A7 v ▶ₐ upg_k k)) `ₜ⊛ a)))
      cbn - [ it_eq_map ].
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_map ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App (v `ᵥ⊛ a) (k `ₜ⊛ a))))
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App
           ((p_of_w A7 v `ᵥ⊛ᵣ r_pop
             `ᵥ⊛ (p_dom_of_w A7 v ▶ₐ upg_k k)) `ᵥ⊛ a)
           (upg_k k `ₜ⊛ a))))
      rewrite w_sub_ren.
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_map ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App (v `ᵥ⊛ a) (k `ₜ⊛ a))))
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App
           ((p_of_w A7 v
             `ᵥ⊛ r_pop ᵣ⊛ (p_dom_of_w A7 v ▶ₐ upg_k k))
            `ᵥ⊛ a) (upg_k k `ₜ⊛ a))))
      change (r_pop ᵣ⊛ (p_dom_of_w _ v ▶ₐ _))%asgn with (p_dom_of_w _ v).
Γ: neg_ctx
A7, B2: pre_ty
i: Γ ∋ ↑ (A7 `→ B2)
v: whn Γ A7
k: term Γ ¬ B2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_map ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App (v `ᵥ⊛ a) (k `ₜ⊛ a))))
  (eval
     (Cut (Val (a ↑ (A7 `→ B2) i))
        (App ((p_of_w A7 v `ᵥ⊛ p_dom_of_w A7 v) `ᵥ⊛ a)
           (upg_k k `ₜ⊛ a))))
      now rewrite (refold_id_aux _ v).
    +
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match
    eval_aux
      (s_subst Γ (Cut (Val (Lam s)) (App v k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Val (Lam s)) (App v k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
           (a_shift3 a)) Δ
        ₃[ Lam
             (s_subst
                (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
                (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
                (a_shift3 a)), v `ᵥ⊛ a, k `ₜ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           Γ ₃[ Lam s, v, k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (Lam (s_subst _ _ _ _)) with (upg_v (Lam s) ᵥ⊛ a).
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
           (a_shift3 a)) Δ
        ₃[ upg_v (Lam s) ᵥ⊛ a, v `ᵥ⊛ a, k `ₜ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           Γ ₃[ Lam s, v, k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_k v ᵥ⊛ a).
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
           (a_shift3 a)) Δ
        ₃[ upg_v (Lam s) ᵥ⊛ a, v `ᵥ⊛ a, upg_k k ᵥ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           Γ ₃[ Lam s, v, k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_v v ᵥ⊛ a).
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           (Δ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
           (a_shift3 a)) Δ
        ₃[ upg_v (Lam s) ᵥ⊛ a, upg_v v ᵥ⊛ a,
        upg_k k ᵥ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           Γ ₃[ Lam s, v, k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      rewrite s_sub3_sub.
Γ: neg_ctx
A3, B3: pre_ty
s: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
v: whn Γ A3
k: term Γ ¬ B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     ((s ₜ⊛ ₃[ upg_v (Lam s), upg_v v, upg_k k]) ₜ⊛ a))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3) s
           Γ ₃[ Lam s, v, k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +
Γ: neg_ctx
A1: pre_ty
s: state (Γ ▶ₓ ¬ A1)
k: term Γ ¬ A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eqF ∅ₑ (fun _ : T1 => nf_eq)
  (it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R) T1_0
  match eval_aux (s_subst Γ (Cut (Mu s) k) Δ a) with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => L_nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut (Mu s) k) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => L_nf Γ)) x0) in
               fun c : state Γ => Ret' (eval_aux c))
             T1_0 x)
    | inr y => RetF y
    end
  with
  | RetF r =>
      match
        eval_aux
          (s_subst Γ
             (p_app (Var (nf_var r)) (nf_obs r)
                (nf_args r)) Δ a)
      with
      | inl x =>
          TauF
            (iter
               (fun pat : T1 =>
                let
                'T1_0 as x0 := pat
                 return
                   (state Δ ->
                    itree ∅ₑ
                      ((fun _ : T1 => state Δ) +ᵢ
                       (fun _ : T1 => L_nf Δ)) x0) in
                 fun c : state Δ => Ret' (eval_aux c))
               T1_0 x)
      | inr y => RetF y
      end
  | TauF t =>
      TauF
        ((fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< t)
  | VisF e k =>
      VisF e
        (fun r : ex_falso e =>
         (fun pat : T1 =>
          let
          'T1_0 as x := pat
           return
             (nf op_copat val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => nf op_copat val_n Δ) x)
           in
           fun y : nf op_copat val_n Γ =>
           eval
             (s_subst Γ
                (p_app (Var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end cbn; econstructor; refold_eval.
Γ: neg_ctx
A1: pre_ty
s: state (Γ ▶ₓ ¬ A1)
k: term Γ ¬ A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval
     (s_subst (Δ ▶ₓ ¬ A1)
        (s_subst (Γ ▶ₓ ¬ A1) s (Δ ▶ₓ ¬ A1)
           (a_shift1 a)) Δ ₁[ k `ₜ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ A1) s Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_k v ᵥ⊛ a); rewrite s_sub1_sub.
Γ: neg_ctx
A1: pre_ty
s: state (Γ ▶ₓ ¬ A1)
k: term Γ ¬ A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
  (itree ∅ₑ (fun _ : T1 => nf op_copat val_n Δ))
CIH: forall (c : state Γ) (a : Γ =[ val_n ]> Δ),
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0 (eval (s_subst Γ c Δ a))
(bind_delay' (eval c)
(fun n : nf op_copat val_n Γ =>
eval (s_subst Γ (p_app (Var (nf_var n)) (nf_obs n) (nf_args n)) Δ a)))
a: Γ =[ val_n ]> Δ
it_eq_t ∅ₑ (fun _ : T1 => nf_eq) R T1_0
  (eval ((s ₜ⊛ ₁[ upg_k k]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ ¬ A1) s Γ ₁[ k]))
     (fun y : nf op_copat val_n Γ =>
      eval
        (s_subst Γ
           (p_app (Var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
  -
forall (Γ : neg_ctx) (u : nf op_copat val_n Γ),
Machine.eval (emb u) ≋ ret_delay u cbn; intros ? [ A i [ o γ ]]; cbn; unfold p_app, nf_args, cut_r, fill_args.
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: op_copat A
γ: dom o =[ val_n ]> Γ
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    cbn in o; funelim (v_of_p o); simpl_depind; inversion eqargs.
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ `1; pr2 := PTt |} =
{| pr1 := A †; pr2 := o |}
H0: ↑ `1 = A †
H1: ↑ `1,' PTt = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a, b: pre_ty
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a `× b); pr2 := PPair |} =
{| pr1 := A †; pr2 := o |}
H0: ↑ (a `× b) = A †
H1: ↑ (a `× b),' PPair = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a0, b0: pre_ty
u: pat ↑ a0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a0; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a0 `+ b0); pr2 := PInl u |} =
{| pr1 := A †; pr2 := o |}
H1: ↑ (a0 `+ b0) = A †
H2: ↑ (a0 `+ b0),' PInl u = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Inl u `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a1, b1: pre_ty
u: pat ↑ b1
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ b1; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a1 `+ b1); pr2 := PInr u |} =
{| pr1 := A †; pr2 := o |}
H1: ↑ (a1 `+ b1) = A †
H2: ↑ (a1 `+ b1),' PInr u = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Inr u `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a2, b2: pre_ty
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a2 `→ b2); pr2 := PLam |} =
{| pr1 := A †; pr2 := o |}
H0: ↑ (a2 `→ b2) = A †
H1: ↑ (a2 `→ b2),' PLam = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a3, b3: pre_ty
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a3 `× b3); pr2 := PFst |} =
{| pr1 := A †; pr2 := o |}
H0: ¬ (a3 `× b3) = A †
H1: ¬ (a3 `× b3),' PFst = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Fst (VarR Ctx.top) `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a4, b4: pre_ty
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a4 `× b4); pr2 := PSnd |} =
{| pr1 := A †; pr2 := o |}
H0: ¬ (a4 `× b4) = A †
H1: ¬ (a4 `× b4),' PSnd = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Snd (VarR Ctx.top) `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a5 `→ b5); pr2 := PApp v |} =
{| pr1 := A †; pr2 := o |}
H1: ¬ (a5 `→ b5) = A †
H2: ¬ (a5 `→ b5),' PApp v = A †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in App (v `ᵥ⊛ᵣ r_pop) (VarR Ctx.top)
      `ₜ⊛ γ)) ≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    all: match goal with
         | H : _ = ?A† |- _ => destruct A; dependent destruction H
         end.
Γ: neg_ctx
i: Γ ∋ ¬ `1
o: pat (¬ `1) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ `1; pr2 := PTt |} =
{| pr1 := (¬ `1) †; pr2 := o |}
H1: ↑ `1,' PTt = (¬ `1) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a, b: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a `× b)
o: pat (¬ (a `× b)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a `× b); pr2 := PPair |} =
{| pr1 := (¬ (a `× b)) †; pr2 := o |}
H1: ↑ (a `× b),' PPair = (¬ (a `× b)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a0, b0: pre_ty
u: pat ↑ a0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a0; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a0 `+ b0)
o: pat (¬ (a0 `+ b0)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a0 `+ b0); pr2 := PInl u |} =
{| pr1 := (¬ (a0 `+ b0)) †; pr2 := o |}
H2: ↑ (a0 `+ b0),' PInl u = (¬ (a0 `+ b0)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Inl u `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a1, b1: pre_ty
u: pat ↑ b1
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ b1; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a1 `+ b1)
o: pat (¬ (a1 `+ b1)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a1 `+ b1); pr2 := PInr u |} =
{| pr1 := (¬ (a1 `+ b1)) †; pr2 := o |}
H2: ↑ (a1 `+ b1),' PInr u = (¬ (a1 `+ b1)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Inr u `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a2, b2: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a2 `→ b2)
o: pat (¬ (a2 `→ b2)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ↑ (a2 `→ b2); pr2 := PLam |} =
{| pr1 := (¬ (a2 `→ b2)) †; pr2 := o |}
H1: ↑ (a2 `→ b2),' PLam = (¬ (a2 `→ b2)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in VarL Ctx.top `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a3, b3: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a3 `× b3)
o: pat (↑ (a3 `× b3)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a3 `× b3); pr2 := PFst |} =
{| pr1 := (↑ (a3 `× b3)) †; pr2 := o |}
H1: ¬ (a3 `× b3),' PFst = (↑ (a3 `× b3)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Fst (VarR Ctx.top) `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a4, b4: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a4 `× b4)
o: pat (↑ (a4 `× b4)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a4 `× b4); pr2 := PSnd |} =
{| pr1 := (↑ (a4 `× b4)) †; pr2 := o |}
H1: ¬ (a4 `× b4),' PSnd = (↑ (a4 `× b4)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in Snd (VarR Ctx.top) `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
o: pat (↑ (a5 `→ b5)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := ¬ (a5 `→ b5); pr2 := PApp v |} =
{| pr1 := (↑ (a5 `→ b5)) †; pr2 := o |}
H2: ¬ (a5 `→ b5),' PApp v = (↑ (a5 `→ b5)) †,' o
eval
  (Cut' (Var i)
     (rew [fun projs : sigma (fun A : ty => pat A) =>
           val (pat_dom (pr2 projs)) (pr1 projs)]
          eqargs in App (v `ᵥ⊛ᵣ r_pop) (VarR Ctx.top)
      `ₜ⊛ γ)) ≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    all: dependent destruction eqargs; cbn.
Γ: neg_ctx
i: Γ ∋ ¬ `1
γ: dom PTt =[ val_n ]> Γ
H1: ↑ `1,' PTt = (¬ `1) †,' PTt
eval (Cut (Val (γ ↑ `1 Ctx.top)) (Var i))
≋ ret_delay (i ⋅ PTt ⦇ γ ⦈)
a, b: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a `× b)
γ: dom PPair =[ val_n ]> Γ
H1: ↑ (a `× b),' PPair = (¬ (a `× b)) †,' PPair
eval (Cut (Val (γ ↑ (a `× b) Ctx.top)) (Var i))
≋ ret_delay (i ⋅ PPair ⦇ γ ⦈)
a0, b0: pre_ty
u: pat ↑ a0
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a0; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a0 `+ b0)
γ: dom (PInl u) =[ val_n ]> Γ
H2: ↑ (a0 `+ b0),' PInl u = (¬ (a0 `+ b0)) †,' PInl u
eval (Cut (Val (Inl (u `ᵥ⊛ γ))) (Var i))
≋ ret_delay (i ⋅ PInl u ⦇ γ ⦈)
a1, b1: pre_ty
u: pat ↑ b1
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ b1; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a1 `+ b1)
γ: dom (PInr u) =[ val_n ]> Γ
H2: ↑ (a1 `+ b1),' PInr u = (¬ (a1 `+ b1)) †,' PInr u
eval (Cut (Val (Inr (u `ᵥ⊛ γ))) (Var i))
≋ ret_delay (i ⋅ PInr u ⦇ γ ⦈)
a2, b2: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a2 `→ b2)
γ: dom PLam =[ val_n ]> Γ
H1: ↑ (a2 `→ b2),' PLam = (¬ (a2 `→ b2)) †,' PLam
eval (Cut (Val (γ ↑ (a2 `→ b2) Ctx.top)) (Var i))
≋ ret_delay (i ⋅ PLam ⦇ γ ⦈)
a3, b3: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a3 `× b3)
γ: dom PFst =[ val_n ]> Γ
H1: ¬ (a3 `× b3),' PFst = (↑ (a3 `× b3)) †,' PFst
eval (Cut (Val (Var i)) (Fst (γ ¬ a3 Ctx.top)))
≋ ret_delay (i ⋅ PFst ⦇ γ ⦈)
a4, b4: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a4 `× b4)
γ: dom PSnd =[ val_n ]> Γ
H1: ¬ (a4 `× b4),' PSnd = (↑ (a4 `× b4)) †,' PSnd
eval (Cut (Val (Var i)) (Snd (γ ¬ b4 Ctx.top)))
≋ ret_delay (i ⋅ PSnd ⦇ γ ⦈)
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
H2: ¬ (a5 `→ b5),' PApp v = (↑ (a5 `→ b5)) †,' PApp v
eval
  (Cut (Val (Var i))
     (App (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ) (γ ¬ b5 Ctx.top)))
≋ ret_delay (i ⋅ PApp v ⦇ γ ⦈)
    all: apply it_eq_unstep; cbn; unfold Var; cbn; econstructor.
Γ: neg_ctx
i: Γ ∋ ¬ `1
γ: dom PTt =[ val_n ]> Γ
H1: ↑ `1,' PTt = (¬ `1) †,' PTt
nf_eq (s_var_upg i ⋅ w_split `1 (γ ↑ `1 Ctx.top))
  (i ⋅ PTt ⦇ γ ⦈)
a, b: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a `× b)
γ: dom PPair =[ val_n ]> Γ
H1: ↑ (a `× b),' PPair = (¬ (a `× b)) †,' PPair
nf_eq
  (s_var_upg i
   ⋅ w_split (a `× b) (γ ↑ (a `× b) Ctx.top))
  (i ⋅ PPair ⦇ γ ⦈)
a0, b0: pre_ty
u: pat ↑ a0
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a0; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a0 `+ b0)
γ: dom (PInl u) =[ val_n ]> Γ
H2: ↑ (a0 `+ b0),' PInl u = (¬ (a0 `+ b0)) †,' PInl u
nf_eq
  (s_var_upg i ⋅ w_split (a0 `+ b0) (Inl (u `ᵥ⊛ γ)))
  (i ⋅ PInl u ⦇ γ ⦈)
a1, b1: pre_ty
u: pat ↑ b1
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ b1; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a1 `+ b1)
γ: dom (PInr u) =[ val_n ]> Γ
H2: ↑ (a1 `+ b1),' PInr u = (¬ (a1 `+ b1)) †,' PInr u
nf_eq
  (s_var_upg i ⋅ w_split (a1 `+ b1) (Inr (u `ᵥ⊛ γ)))
  (i ⋅ PInr u ⦇ γ ⦈)
a2, b2: pre_ty
Γ: neg_ctx
i: Γ ∋ ¬ (a2 `→ b2)
γ: dom PLam =[ val_n ]> Γ
H1: ↑ (a2 `→ b2),' PLam = (¬ (a2 `→ b2)) †,' PLam
nf_eq
  (s_var_upg i
   ⋅ w_split (a2 `→ b2) (γ ↑ (a2 `→ b2) Ctx.top))
  (i ⋅ PLam ⦇ γ ⦈)
a3, b3: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a3 `× b3)
γ: dom PFst =[ val_n ]> Γ
H1: ¬ (a3 `× b3),' PFst = (↑ (a3 `× b3)) †,' PFst
nf_eq (fst_nf i (γ ¬ a3 Ctx.top)) (i ⋅ PFst ⦇ γ ⦈)
a4, b4: pre_ty
Γ: neg_ctx
i: Γ ∋ ↑ (a4 `× b4)
γ: dom PSnd =[ val_n ]> Γ
H1: ¬ (a4 `× b4),' PSnd = (↑ (a4 `× b4)) †,' PSnd
nf_eq (snd_nf i (γ ¬ b4 Ctx.top)) (i ⋅ PSnd ⦇ γ ⦈)
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
H2: ¬ (a5 `→ b5),' PApp v = (↑ (a5 `→ b5)) †,' PApp v
nf_eq (app_nf i (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ) (γ ¬ b5 Ctx.top))
  (i ⋅ PApp v ⦇ γ ⦈)
    1-2,5-7: econstructor; intros ? v; repeat (dependent elimination v; auto).
a0, b0: pre_ty
u: pat ↑ a0
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a0; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a0 `+ b0)
γ: dom (PInl u) =[ val_n ]> Γ
H2: ↑ (a0 `+ b0),' PInl u = (¬ (a0 `+ b0)) †,' PInl u
nf_eq
  (s_var_upg i ⋅ w_split (a0 `+ b0) (Inl (u `ᵥ⊛ γ)))
  (i ⋅ PInl u ⦇ γ ⦈)
a1, b1: pre_ty
u: pat ↑ b1
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ b1; pr2 := u |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in u = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ¬ (a1 `+ b1)
γ: dom (PInr u) =[ val_n ]> Γ
H2: ↑ (a1 `+ b1),' PInr u = (¬ (a1 `+ b1)) †,' PInr u
nf_eq
  (s_var_upg i ⋅ w_split (a1 `+ b1) (Inr (u `ᵥ⊛ γ)))
  (i ⋅ PInr u ⦇ γ ⦈)
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
H2: ¬ (a5 `→ b5),' PApp v = (↑ (a5 `→ b5)) †,' PApp v
nf_eq (app_nf i (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ) (γ ¬ b5 Ctx.top))
  (i ⋅ PApp v ⦇ γ ⦈)
    1-2: exact (nf_eq_split _ _ γ).
a5, b5: pre_ty
v: pat ↑ a5
H: forall (Γ : neg_ctx) (A : ty) (i : Γ ∋ A)
  (o : pat A †) (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := ↑ a5; pr2 := v |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun A0 : ty => pat A0) =>
     val (pat_dom (pr2 projs)) (pr1 projs)]
    eqargs in v = o ->
eval (Cut' (Var i) (o `ₜ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
H2: ¬ (a5 `→ b5),' PApp v = (↑ (a5 `→ b5)) †,' PApp v
nf_eq (app_nf i (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ) (γ ¬ b5 Ctx.top))
  (i ⋅ PApp v ⦇ γ ⦈)
    (* a bit of an ugly case because we didn't write proper generic functions
       for splitting negative values.. hence knowing this one is an App is
       getting in our way *)
    clear; unfold app_nf.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ᵣ r_pop `ᵥ⊛ γ)
       ▶ₐ γ ¬ b5 Ctx.top ⦈) (i ⋅ PApp v ⦇ γ ⦈)
    rewrite w_sub_ren.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ r_pop ᵣ⊛ γ))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ r_pop ᵣ⊛ γ)
       ▶ₐ γ ¬ b5 Ctx.top ⦈) (i ⋅ PApp v ⦇ γ ⦈)
    pose (γ' := (r_pop ᵣ⊛ γ)%asgn);
      change (sub_elt _) with (pat_dom v : t_ctx) in γ' at 1; cbn in γ'.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
γ':= (r_pop ᵣ⊛ γ)%asgn: pat_dom v =[ val ]> Γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ r_pop ᵣ⊛ γ))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ r_pop ᵣ⊛ γ)
       ▶ₐ γ ¬ b5 Ctx.top ⦈) (i ⋅ PApp v ⦇ γ ⦈)
    change (r_pop ᵣ⊛ γ)%asgn with γ'.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
γ':= (r_pop ᵣ⊛ γ)%asgn: pat_dom v =[ val ]> Γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ γ'))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ γ') ▶ₐ γ ¬ b5 Ctx.top ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    pose (vv := γ _ Ctx.top); cbn in vv; change (γ _ Ctx.top) with vv.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
γ':= (r_pop ᵣ⊛ γ)%asgn: pat_dom v =[ val ]> Γ
vv:= γ ¬ b5 Ctx.top: term Γ ¬ b5
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ γ'))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ γ') ▶ₐ vv ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    assert (H : [ γ' ,ₓ upg_k vv ] ≡ₐ γ) by now intros ? ii; dependent elimination ii.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
γ':= (r_pop ᵣ⊛ γ)%asgn: pat_dom v =[ val ]> Γ
vv:= γ ¬ b5 Ctx.top: term Γ ¬ b5
H: γ' ▶ₐ upg_k vv ≡ₐ γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ γ'))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ γ') ▶ₐ vv ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    remember γ' as a; remember vv as t; clear γ' vv Heqa Heqt.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ a))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ a) ▶ₐ t ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    pose proof (p_dom_of_w_eq _ v a).
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    p_of_w_eq a5 v a in
p_dom_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a)
≡ₐ a
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ a))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ a) ▶ₐ t ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    pose (H' := p_of_w_eq _ v a); fold H' in H0.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H':= p_of_w_eq a5 v a: p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a) = v
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    H' in
p_dom_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a)
≡ₐ a
nf_eq
  (i
   ⋅ PApp (p_of_w a5 (v `ᵥ⊛ a))
     ⦇ p_dom_of_w a5 (v `ᵥ⊛ a) ▶ₐ t ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    pose (aa := p_dom_of_w _ ((v : val _ _) `ᵥ⊛ a)); fold aa in H0 |- *.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H':= p_of_w_eq a5 v a: p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a) = v
aa:= p_dom_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a): pat_dom
  (p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a)) =[
val ]> Γ
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    H' in aa ≡ₐ a
nf_eq (i ⋅ PApp (p_of_w a5 (v `ᵥ⊛ a)) ⦇ aa ▶ₐ t ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    remember aa as a'; clear aa Heqa'.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H':= p_of_w_eq a5 v a: p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a) = v
a': pat_dom
  (p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a)) =[
val ]> Γ
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    H' in a' ≡ₐ a
nf_eq (i ⋅ PApp (p_of_w a5 (v `ᵥ⊛ a)) ⦇ a' ▶ₐ t ⦈)
  (i ⋅ PApp v ⦇ γ ⦈)
    revert a' H0; rewrite H'; intros; econstructor.
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H':= p_of_w_eq a5 v a: p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a) = v
a': pat_dom v =[ val ]> Γ
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    eq_refl in a' ≡ₐ a
a' ▶ₐ t ≡ₐ γ
    etransitivity; [ | exact H ].
a5, b5: pre_ty
v: pat ↑ a5
Γ: neg_ctx
i: Γ ∋ ↑ (a5 `→ b5)
γ: dom (PApp v) =[ val_n ]> Γ
a: pat_dom v =[ val ]> Γ
t: term Γ ¬ b5
H: a ▶ₐ upg_k t ≡ₐ γ
H':= p_of_w_eq a5 v a: p_of_w a5 ((v : val (pat_dom v) ↑ a5) `ᵥ⊛ a) = v
a': pat_dom v =[ val ]> Γ
H0: rew [fun p : pat ↑ a5 => pat_dom p =[ val ]> Γ]
    eq_refl in a' ≡ₐ a
a' ▶ₐ t ≡ₐ a ▶ₐ upg_k t
    refine (a_append_eq _ _ _ _ _ _); auto.
  -
well_founded head_inst_nostep intros A; econstructor; intros [ B m ] H; dependent elimination H;
      cbn [projT1 projT2] in i, i0.
y: ty
o: op_copat y
B: ty
m: op_copat B
Γ: neg_ctx
v: val_n Γ y
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var v -> T0
i0: evalₒ (v ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    destruct y.
p: pre_ty
o: op_copat ↑ p
B: ty
m: op_copat B
Γ: neg_ctx
v: val Γ ↑ p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var v -> T0
i0: evalₒ (v ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty
o: op_copat ¬ p
B: ty
m: op_copat B
Γ: neg_ctx
v: val Γ ¬ p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var v -> T0
i0: evalₒ (v ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: dependent elimination v; try now destruct (t0 (Vvar _)).
A0, B0: pre_ty
o: op_copat ↑ (A0 `+ B0)
B: ty
m: op_copat B
Γ: neg_ctx
w: whn Γ A0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Inl w) -> T0
i0: evalₒ (Inl w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B1: pre_ty
o: op_copat ↑ (A1 `+ B1)
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ B1
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Inr w0) -> T0
i0: evalₒ (Inr w0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: op_copat ↑ `1
B: ty
m: op_copat B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var Tt -> T0
i0: evalₒ (Tt ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B2: pre_ty
o: op_copat ↑ (A2 `× B2)
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ A2)
s0: state (Γ ▶ₓ ¬ B2)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Pair s s0) -> T0
i0: evalₒ (Pair s s0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty
o: op_copat ↑ (A3 `→ B3)
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Lam s1) -> T0
i0: evalₒ (Lam s1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2: pre_ty
o: op_copat ¬ A2
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ A2)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (MuT s0) -> T0
i0: evalₒ (MuT s0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: op_copat ¬ `0
B: ty
m: op_copat B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var Boom -> T0
i0: evalₒ (Boom ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B0: pre_ty
o: op_copat ¬ (A3 `+ B0)
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ A3)
s2: state (Γ ▶ₓ ↑ B0)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Case s1 s2) -> T0
i0: evalₒ (Case s1 s2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B1: pre_ty
o: op_copat ¬ (A4 `× B1)
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ A4
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Fst t1) -> T0
i0: evalₒ (Fst t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B2: pre_ty
o: op_copat ¬ (A5 `× B2)
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ B2
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Snd t2) -> T0
i0: evalₒ (Snd t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B3: pre_ty
o: op_copat ¬ (A6 `→ B3)
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ A6
t3: term Γ ¬ B3
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (App w0 t3) -> T0
i0: evalₒ (App w0 t3 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: clear t0.
A0, B0: pre_ty
o: op_copat ↑ (A0 `+ B0)
B: ty
m: op_copat B
Γ: neg_ctx
w: whn Γ A0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Inl w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B1: pre_ty
o: op_copat ↑ (A1 `+ B1)
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ B1
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Inr w0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: op_copat ↑ `1
B: ty
m: op_copat B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Tt ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B2: pre_ty
o: op_copat ↑ (A2 `× B2)
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ A2)
s0: state (Γ ▶ₓ ¬ B2)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Pair s s0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty
o: op_copat ↑ (A3 `→ B3)
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Lam s1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2: pre_ty
o: op_copat ¬ A2
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ A2)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (MuT s0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: op_copat ¬ `0
B: ty
m: op_copat B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Boom ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B0: pre_ty
o: op_copat ¬ (A3 `+ B0)
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ A3)
s2: state (Γ ▶ₓ ↑ B0)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Case s1 s2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B1: pre_ty
o: op_copat ¬ (A4 `× B1)
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ A4
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Fst t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B2: pre_ty
o: op_copat ¬ (A5 `× B2)
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ B2
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Snd t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B3: pre_ty
o: op_copat ¬ (A6 `→ B3)
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ A6
t3: term Γ ¬ B3
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (App w0 t3 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: cbn in o; dependent elimination o; cbn in i0.
a4, b3: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ a4)
s0: state (Γ ▶ₓ ¬ b3)
a: dom PFst =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (Pair s s0)) (Fst (a ¬ a4 Ctx.top)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a5, b4: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ a5)
s0: state (Γ ▶ₓ ¬ b4)
a: dom PSnd =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (Pair s s0)) (Snd (a ¬ b4 Ctx.top)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a6, b5: pre_ty
p1: pat ↑ a6
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ (a6 `→ b5) ▶ₓ ↑ a6 ▶ₓ ¬ b5)
a: dom (PApp p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (Lam s1))
     (App (p1 `ᵥ⊛ᵣ r_pop `ᵥ⊛ a) (a ¬ b5 Ctx.top)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ `1)
a: dom PTt =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (a ↑ `1 Ctx.top)) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a0 `× b))
a: dom PPair =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (a ↑ (a0 `× b) Ctx.top)) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a1, b0: pre_ty
p: pat ↑ a1
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a1 `+ b0))
a: dom (PInl p) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inl (p `ᵥ⊛ a))) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a2, b1: pre_ty
p0: pat ↑ b1
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a2 `+ b1))
a: dom (PInr p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inr (p0 `ᵥ⊛ a))) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a3 `→ b2))
a: dom PLam =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (a ↑ (a3 `→ b2) Ctx.top)) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a1, b0: pre_ty
p: pat ↑ a1
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ a1)
s2: state (Γ ▶ₓ ↑ b0)
a: dom (PInl p) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inl (p `ᵥ⊛ a))) (Case s1 s2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a2, b1: pre_ty
p0: pat ↑ b1
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ a2)
s2: state (Γ ▶ₓ ↑ b1)
a: dom (PInr p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inr (p0 `ᵥ⊛ a))) (Case s1 s2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ a0
a: dom PPair =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (a ↑ (a0 `× b) Ctx.top)) (Fst t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ b
a: dom PPair =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (a ↑ (a0 `× b) Ctx.top)) (Snd t2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
a: dom PLam =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (a ↑ (a3 `→ b2) Ctx.top)) (App w0 t3))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: match goal with
         | u : dom _ =[val_n]> _ |- _ =>
             cbn in i0;
             pose (vv := u _ Ctx.top); change (u _ Ctx.top) with vv in i0;
             remember vv as v'; clear u vv Heqv'; cbn in v'
         | _ => idtac
       end.
a4, b3: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ a4)
s0: state (Γ ▶ₓ ¬ b3)
i: Γ ∋ B
v': term Γ ¬ a4
i0: evalₒ (Cut (Val (Pair s s0)) (Fst v'))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a5, b4: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s: state (Γ ▶ₓ ¬ a5)
s0: state (Γ ▶ₓ ¬ b4)
i: Γ ∋ B
v': term Γ ¬ b4
i0: evalₒ (Cut (Val (Pair s s0)) (Snd v'))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a6, b5: pre_ty
p1: pat ↑ a6
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ (a6 `→ b5) ▶ₓ ↑ a6 ▶ₓ ¬ b5)
a: dom (PApp p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut (Val (Lam s1))
     (App (p1 `ᵥ⊛ᵣ r_pop `ᵥ⊛ a) (a ¬ b5 Ctx.top)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ `1)
i: Γ ∋ B
v': whn Γ `1
i0: evalₒ (Cut (Val v') (MuT s0)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a0 `× b))
i: Γ ∋ B
v': whn Γ (a0 `× b)
i0: evalₒ (Cut (Val v') (MuT s0)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a1, b0: pre_ty
p: pat ↑ a1
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a1 `+ b0))
a: dom (PInl p) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inl (p `ᵥ⊛ a))) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a2, b1: pre_ty
p0: pat ↑ b1
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a2 `+ b1))
a: dom (PInr p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inr (p0 `ᵥ⊛ a))) (MuT s0))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
s0: state (Γ ▶ₓ ↑ (a3 `→ b2))
i: Γ ∋ B
v': whn Γ (a3 `→ b2)
i0: evalₒ (Cut (Val v') (MuT s0)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a1, b0: pre_ty
p: pat ↑ a1
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ a1)
s2: state (Γ ▶ₓ ↑ b0)
a: dom (PInl p) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inl (p `ᵥ⊛ a))) (Case s1 s2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a2, b1: pre_ty
p0: pat ↑ b1
B: ty
m: op_copat B
Γ: neg_ctx
s1: state (Γ ▶ₓ ↑ a2)
s2: state (Γ ▶ₓ ↑ b1)
a: dom (PInr p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut (Val (Inr (p0 `ᵥ⊛ a))) (Case s1 s2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ a0
i: Γ ∋ B
v': whn Γ (a0 `× b)
i0: evalₒ (Cut (Val v') (Fst t1)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ b
i: Γ ∋ B
v': whn Γ (a0 `× b)
i0: evalₒ (Cut (Val v') (Snd t2)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
i: Γ ∋ B
v': whn Γ (a3 `→ b2)
i0: evalₒ (Cut (Val v') (App w0 t3))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    1-10: now apply it_eq_step in i0; inversion i0.
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ a0
i: Γ ∋ B
v': whn Γ (a0 `× b)
i0: evalₒ (Cut (Val v') (Fst t1)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ b
i: Γ ∋ B
v': whn Γ (a0 `× b)
i0: evalₒ (Cut (Val v') (Snd t2)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
i: Γ ∋ B
v': whn Γ (a3 `→ b2)
i0: evalₒ (Cut (Val v') (App w0 t3))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: dependent elimination v'; [ | apply it_eq_step in i0; now inversion i0 ].
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t1: term Γ ¬ a0
i: Γ ∋ B
c: Γ ∋ ↑ (a0 `× b)
i0: evalₒ (Cut (Val (VarL c)) (Fst t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a0, b: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
t2: term Γ ¬ b
i: Γ ∋ B
c: Γ ∋ ↑ (a0 `× b)
i0: evalₒ (Cut (Val (VarL c)) (Snd t2))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
a3, b2: pre_ty
B: ty
m: op_copat B
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
i: Γ ∋ B
c: Γ ∋ ↑ (a3 `→ b2)
i0: evalₒ (Cut (Val (VarL c)) (App w0 t3))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all:
      apply it_eq_step in i0; cbn in i0; dependent elimination i0; cbn in r_rel;
      apply noConfusion_inv in r_rel; unfold w_split in r_rel;
      cbn in r_rel; unfold NoConfusionHom_f_cut,s_var_upg in r_rel; cbn in r_rel;
      pose proof (H := f_equal pr1 r_rel); cbn in H; dependent destruction H;
      apply DepElim.pr2_uip in r_rel;
      pose proof (H := f_equal pr1 r_rel); cbn in H; dependent destruction H;
      apply DepElim.pr2_uip in r_rel; dependent destruction r_rel.
a0, b: pre_ty
Γ: neg_ctx
t1: term Γ ¬ a0
c: Γ ∋ ↑ (a0 `× b)
Acc head_inst_nostep (↑ (a0 `× b),' PFst)
a0, b: pre_ty
Γ: neg_ctx
t2: term Γ ¬ b
c: Γ ∋ ↑ (a0 `× b)
Acc head_inst_nostep (↑ (a0 `× b),' PSnd)
a3, b2: pre_ty
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
c: Γ ∋ ↑ (a3 `→ b2)
Acc head_inst_nostep
  (↑ (a3 `→ b2),' PApp (p_of_w a3 w0))
    all:
      econstructor; intros [ t o ] H; cbn in t,o; dependent elimination H.
a0, b: pre_ty
Γ: neg_ctx
t1: term Γ ¬ a0
c: Γ ∋ ↑ (a0 `× b)
t: ty
o: pat t †
Γ0: neg_ctx
v: val_n Γ0 ↑ (a0 `× b)
a: dom PFst =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var v -> T0
i0: evalₒ (v ⊙ PFst ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
a0, b: pre_ty
Γ: neg_ctx
t2: term Γ ¬ b
c: Γ ∋ ↑ (a0 `× b)
t: ty
o: pat t †
Γ0: neg_ctx
v: val_n Γ0 ↑ (a0 `× b)
a: dom PSnd =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var v -> T0
i0: evalₒ (v ⊙ PSnd ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
a3, b2: pre_ty
Γ: neg_ctx
w0: whn Γ a3
t3: term Γ ¬ b2
c: Γ ∋ ↑ (a3 `→ b2)
t: ty
o: pat t †
Γ0: neg_ctx
v: val_n Γ0 ↑ (a3 `→ b2)
a: dom (PApp (p_of_w a3 w0)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var v -> T0
i0: evalₒ (v ⊙ PApp (p_of_w a3 w0) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
    all: dependent elimination v; try now destruct (t0 (Vvar _)).
A2, B2: pre_ty
Γ: neg_ctx
t1: term Γ ¬ A2
c: Γ ∋ ↑ (A2 `× B2)
t: ty
o: pat t †
Γ0: neg_ctx
s: state (Γ0 ▶ₓ ¬ A2)
s0: state (Γ0 ▶ₓ ¬ B2)
a: dom PFst =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Pair s s0) -> T0
i0: evalₒ (Pair s s0 ⊙ PFst ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A2, B2: pre_ty
Γ: neg_ctx
t2: term Γ ¬ B2
c: Γ ∋ ↑ (A2 `× B2)
t: ty
o: pat t †
Γ0: neg_ctx
s: state (Γ0 ▶ₓ ¬ A2)
s0: state (Γ0 ▶ₓ ¬ B2)
a: dom PSnd =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Pair s s0) -> T0
i0: evalₒ (Pair s s0 ⊙ PSnd ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A3, B3: pre_ty
Γ: neg_ctx
w0: whn Γ A3
t3: term Γ ¬ B3
c: Γ ∋ ↑ (A3 `→ B3)
t: ty
o: pat t †
Γ0: neg_ctx
s1: state (Γ0 ▶ₓ ↑ (A3 `→ B3) ▶ₓ ↑ A3 ▶ₓ ¬ B3)
a: dom (PApp (p_of_w A3 w0)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Lam s1) -> T0
i0: evalₒ (Lam s1 ⊙ PApp (p_of_w A3 w0) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
    all: apply it_eq_step in i0; cbn in i0; now inversion i0.
Qed.

Definition subst_eq (Δ : neg_ctx) {Γ} : relation (state Γ) :=
  fun u v => forall (σ : Γ =[val]> Δ), evalₒ (u ₜ⊛ σ : state_n Δ) ≈ evalₒ (v ₜ⊛ σ : state_n Δ) .
Notation "x ≈⟦sub Δ ⟧≈ y" := (subst_eq Δ x y) (at level 50).

Theorem subst_correct (Δ : neg_ctx) {Γ : neg_ctx} (x y : state Γ)
  : x ≈⟦ogs Δ ⟧≈ y -> x ≈⟦sub Δ ⟧≈ y.
Δ, Γ: neg_ctx
x, y: state Γ
x ≈⟦ogs Δ ⟧≈ y -> x ≈⟦sub Δ ⟧≈ y
  exact (ogs_correction _ x y).
Qed.

Definition c_of_t {Γ : neg_ctx} {A} (t : term Γ ↑A)
           : state_n (Γ ▶ₛ {| sub_elt := ¬A ; sub_prf := stt |}) :=
  Cut (t_shift1 _ t) (VarR Ctx.top) .
Notation "'name⁺'" := c_of_t.

Definition a_of_sk {Γ Δ : neg_ctx} {A} (s : Γ =[val]> Δ) (k : term Δ ¬A)
  : (Γ ▶ₛ {| sub_elt := ¬A ; sub_prf := stt |}) =[val_n]> Δ :=
  [ s ,ₓ k : val _ ¬_ ].

Lemma sub_csk {Γ Δ : neg_ctx} {A} (t : term Γ ↑A) (s : Γ =[val]> Δ)
  (k : term Δ ¬A)
  : Cut (t `ₜ⊛ s) k = c_of_t t ₜ⊛ a_of_sk s k.
Γ, Δ: neg_ctx
A: pre_ty
t: term Γ ↑ A
s: Γ =[ val ]> Δ
k: term Δ ¬ A
Cut (t `ₜ⊛ s) k = name⁺ t ₜ⊛ a_of_sk s k
Proof.
Γ, Δ: neg_ctx
A: pre_ty
t: term Γ ↑ A
s: Γ =[ val ]> Δ
k: term Δ ¬ A
Cut (t `ₜ⊛ s) k = name⁺ t ₜ⊛ a_of_sk s k
  cbn; f_equal; unfold t_shift1; rewrite t_sub_ren; now apply t_sub_eq.
Qed.

Definition ciu_eq (Δ : neg_ctx) {Γ A} : relation (term Γ ↑A) :=
  fun u v =>
    forall (σ : Γ =[val]> Δ) (k : term Δ ¬A),
      evalₒ (Cut (u `ₜ⊛ σ) k : state_n Δ) ≈ evalₒ (Cut (v `ₜ⊛ σ) k : state_n Δ) .
Notation "x ≈⟦ciu Δ ⟧⁺≈ y" := (ciu_eq Δ x y) (at level 50).

Theorem ciu_correct (Δ : neg_ctx) {Γ : neg_ctx} {A} (x y : term Γ ↑A)
  : (name⁺ x) ≈⟦ogs Δ ⟧≈ (name⁺ y) -> x ≈⟦ciu Δ ⟧⁺≈ y.
Δ, Γ: neg_ctx
A: pre_ty
x, y: term Γ ↑ A
name⁺ x ≈⟦ogs Δ ⟧≈ name⁺ y -> x ≈⟦ciu Δ ⟧⁺≈ y
  intros H σ k; rewrite 2 sub_csk.
Δ, Γ: neg_ctx
A: pre_ty
x, y: term Γ ↑ A
H: name⁺ x ≈⟦ogs Δ ⟧≈ name⁺ y
σ: Γ =[ val ]> Δ
k: term Δ ¬ A
evalₒ (name⁺ x ₜ⊛ a_of_sk σ k)
≈ evalₒ (name⁺ y ₜ⊛ a_of_sk σ k)
  now apply subst_correct.
Qed.