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.

In this file we instanciate our OGS construction with the fully-dual polarized mu-mu-tilde calculus 'System D' from P. Downen & Z. Ariola. The presentation may be slightly unusual as we go for one-sided sequent. The only real divergence from the original calculus is the addition of a restricted form of recursion, making the language non-normalizing.

Types

Type have polarities, basically whether their values are CBV-biased or CBN-biased

Variant pol : Type := pos | neg .

Syntax of types. We have a fully dual type system with:

0, positive void (no constructor),
⊤, negative unit (no destructor),
⊥, negative void (one trivial destructor),
1, positive unit (one trivial constructor),
A ⊗ B, positive product (pairs with pattern-matching),
A ⅋ B, negative sum (one binary destructor),
A ⊕ B, positive sum (usual coproduct with injections),
A & B, negative product (usual product with projections),
↓ A, positive shift (thunking),
↑ A, negative shift ('returners'),
⊖ A, positive negation (approximately continuations accepting an A),
¬ A, negative negation (approximately refutations of A).

We opt for an explicit treatment of polarity, by indexing the family of types.

Inductive pre_ty : pol -> Type :=
| Zer : pre_ty pos
| Top : pre_ty neg
| One : pre_ty pos
| Bot : pre_ty neg
| Tens : pre_ty pos -> pre_ty pos -> pre_ty pos
| Par : pre_ty neg -> pre_ty neg -> pre_ty neg
| Or : pre_ty pos -> pre_ty pos -> pre_ty pos
| And : pre_ty neg -> pre_ty neg -> pre_ty neg
| ShiftP : pre_ty neg -> pre_ty pos
| ShiftN : pre_ty pos -> pre_ty neg
| NegP : pre_ty neg -> pre_ty pos
| NegN : pre_ty pos -> pre_ty neg
.

Notation "0" := (Zer) : ty_scope .
Notation "1" := (One) : ty_scope .
Notation "⊤" := (Top) : ty_scope .
Notation "⊥" := (Bot) : ty_scope .
Notation "A ⊗ B" := (Tens A B) (at level 40) : ty_scope.
Notation "A ⅋ B" := (Par A B) (at level 40) : ty_scope .
Notation "A ⊕ B" := (Or A B) (at level 40) : ty_scope.
Notation "A & B" := (And A B) (at level 40) : ty_scope.
Notation "↓ A" := (ShiftP A) (at level 40) : ty_scope.
Notation "↑ A" := (ShiftN A) (at level 40) : ty_scope.
Notation "⊖ A" := (NegP A) (at level 5) : ty_scope .
Notation "¬ A" := (NegN A) (at level 5) : ty_scope .

As hinted above, we go for one-sided sequents. This enables to have only one context instead of two, simplifying the theory of substitution. On the flip-side, as we still need two kinds of variables, the 'normal' ones and the co-variables, our contexts will not contain bare types but side-annotated types. A variable of type A will thus be stored as \`-A in the context while a co-variable of type A will be stored as \`-A.

Variant ty : Type :=
| LTy {p} : pre_ty p -> ty
| RTy {p} : pre_ty p -> ty
.

Notation "'`+' t" := (LTy t) (at level 5) : ty_scope .
Notation "'`-' t" := (RTy t) (at level 5) : 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.

Finally we define contexts as backward lists of side-annotated types.

Definition t_ctx : Type := Ctx.ctx ty.

Terms

We define the well-typed syntax of the language with 3 mutually defined syntactic categories: terms, weak head-normal forms and states ('language configurations' in the paper).

Nothing should be too surprising. A first notable point is that by choosing to have an explicit notion of 'side' of a variable, we can have a single construct for both mu and mu-tilde. A second notable point is our new slightly exotic RecL and RecR constructions. They allow arbitrary recursion at co-terms of positive types and at terms of negative types. These polarity restrictions allow us to have minimal disruption of the evaluation rules.

Inductive term : t_ctx -> ty -> Type :=
| Mu {Γ A} : state (Γ ▶ₓ A†) -> term Γ A
| RecL {Γ} {A : pre_ty pos} : term (Γ ▶ₓ `-A) `-A -> term Γ `-A
| RecR {Γ} {A : pre_ty neg} : term (Γ ▶ₓ `+A) `+A -> term Γ `+A
| Whn {Γ A} : whn Γ A -> term Γ A
with whn : t_ctx -> ty -> Type :=
| Var {Γ A} : Γ ∋ A -> whn Γ A
| ZerL {Γ} : whn Γ `-0
| TopR {Γ} : whn Γ `+⊤
| OneR {Γ} : whn Γ `+1
| OneL {Γ} : state Γ -> whn Γ `-1
| BotR {Γ} : state Γ -> whn Γ `+⊥
| BotL {Γ} : whn Γ `-⊥
| TenR {Γ A B} : whn Γ `+A -> whn Γ `+B -> whn Γ `+(A ⊗ B)
| TenL {Γ A B} : state (Γ ▶ₓ `+A ▶ₓ `+B) -> whn Γ `-(A ⊗ B)
| ParR {Γ A B} : state (Γ ▶ₓ `-A ▶ₓ `-B) -> whn Γ `+(A ⅋ B)
| ParL {Γ A B} : whn Γ `-A -> whn Γ `-B -> whn Γ `-(A ⅋ B)
| OrR1 {Γ A B} : whn Γ `+A -> whn Γ `+(A ⊕ B)
| OrR2 {Γ A B} : whn Γ `+B -> whn Γ `+(A ⊕ B)
| OrL {Γ A B} : state (Γ ▶ₓ `+A) -> state (Γ ▶ₓ `+B) -> whn Γ `-(A ⊕ B)
| AndR {Γ A B} : state (Γ ▶ₓ `-A) -> state (Γ ▶ₓ `-B) -> whn Γ `+(A & B)
| AndL1 {Γ A B} : whn Γ `-A -> whn Γ `-(A & B)
| AndL2 {Γ A B} : whn Γ `-B -> whn Γ `-(A & B)
| ShiftPR {Γ A} : term Γ `+A -> whn Γ `+(↓ A)
| ShiftPL {Γ A} : state (Γ ▶ₓ `+A) -> whn Γ `-(↓ A)
| ShiftNR {Γ A} : state (Γ ▶ₓ `-A) -> whn Γ `+(↑ A)
| ShiftNL {Γ A} : term Γ `-A -> whn Γ `-(↑ A)
| NegPR {Γ A} : whn Γ `-A -> whn Γ `+(⊖ A)
| NegPL {Γ A} : state (Γ ▶ₓ `-A) -> whn Γ `-(⊖ A)
| NegNR {Γ A} : state (Γ ▶ₓ `+A) -> whn Γ `+(¬ A)
| NegNL {Γ A} : whn Γ `+A -> whn Γ `-(¬ A)
with state : t_ctx -> Type :=
| Cut {Γ} p {A : pre_ty p} : term Γ `+A -> term Γ `-A -> state Γ
.

Definition Cut' {Γ A} : term Γ A -> term Γ A† -> state Γ :=
  match A with
  | `+A => fun t1 t2 => Cut _ t1 t2
  | `-A => fun t1 t2 => Cut _ t2 t1
  end .

Values are not exactly weak head-normal forms, but depend on the polarity of the type. As positive types have CBV evaluation, their values are weak head-normal forms, but their co-values (evaluation contexts) are just any co-term (context) as they are delayed anyways. Dually for negative types, values are delayed hence can be any term while co-values must be weak head-normal form contexts.

Equations val : t_ctx -> ty -> Type :=
  val Γ (@LTy pos A) := whn Γ `+A ;
  val Γ (@RTy pos A) := term Γ `-A ;
  val Γ (@LTy neg A) := term Γ `+A ;
  val Γ (@RTy neg A) := whn Γ `-A .
Arguments val _ _ /.

We provide a 'smart-constructor' for variables, embedding variables in values.

Equations var : c_var ⇒₁ val :=
  var _ (@LTy pos _) i := Var i ;
  var _ (@RTy pos _) i := Whn (Var i) ;
  var _ (@LTy neg _) i := Whn (Var i) ;
  var _ (@RTy neg _) i := Var i .
#[global] Arguments var {Γ} [x] / i.

Renaming

Without surprise parallel renaming goes by a big mutual induction, shifting the renaming apropriately while going under binders. Note the use of the internal substitution hom to type it.

Equations t_rename : term ⇒₁ ⟦ c_var , term ⟧₁ :=
  t_rename _ _ (Mu c)    _ f := Mu (s_rename _ c _ (r_shift1 f)) ;
  t_rename _ _ (RecL t)  _ f := RecL (t_rename _ _ t _ (r_shift1 f)) ;
  t_rename _ _ (RecR t)  _ f := RecR (t_rename _ _ t _ (r_shift1 f)) ;
  t_rename _ _ (Whn v)   _ f := Whn (w_rename _ _ v _ f) ;
with w_rename : whn ⇒₁ ⟦ c_var , whn ⟧₁ :=
  w_rename _  _ (Var i)       _ f := Var (f _ i) ;
  w_rename _  _ (ZerL)        _ f := ZerL ;
  w_rename _  _ (TopR)        _ f := TopR ;
  w_rename _  _ (OneR)        _ f := OneR ;
  w_rename _  _ (OneL c)      _ f := OneL (s_rename _ c _ f) ;
  w_rename _  _ (BotR c)      _ f := BotR (s_rename _ c _ f) ;
  w_rename _  _ (BotL)        _ f := BotL ;
  w_rename _  _ (TenR v1 v2)  _ f := TenR (w_rename _ _ v1 _ f) (w_rename _ _ v2 _ f) ;
  w_rename _  _ (TenL c)      _ f := TenL (s_rename _ c _ (r_shift2 f)) ;
  w_rename _  _ (ParR c)      _ f := ParR (s_rename _ c _ (r_shift2 f)) ;
  w_rename _  _ (ParL k1 k2)  _ f := ParL (w_rename _ _ k1 _ f) (w_rename _ _ k2 _ f) ;
  w_rename _  _ (OrR1 v)      _ f := OrR1 (w_rename _ _ v _ f) ;
  w_rename _  _ (OrR2 v)      _ f := OrR2 (w_rename _ _ v _ f) ;
  w_rename _  _ (OrL c1 c2)   _ f := OrL (s_rename _ c1 _ (r_shift1 f))
                                         (s_rename _ c2 _ (r_shift1 f)) ;
  w_rename _  _ (AndR c1 c2)  _ f := AndR (s_rename _ c1 _ (r_shift1 f))
                                          (s_rename _ c2 _ (r_shift1 f)) ;
  w_rename _  _ (AndL1 k)     _ f := AndL1 (w_rename _ _ k _ f) ;
  w_rename _  _ (AndL2 k)     _ f := AndL2 (w_rename _ _ k _ f) ;
  w_rename _  _ (ShiftPR t)   _ f := ShiftPR (t_rename _ _ t _ f) ;
  w_rename _  _ (ShiftPL c)   _ f := ShiftPL (s_rename _ c _ (r_shift1 f)) ;
  w_rename _  _ (ShiftNR c)   _ f := ShiftNR (s_rename _ c _ (r_shift1 f)) ;
  w_rename _  _ (ShiftNL t)   _ f := ShiftNL (t_rename _ _ t _ f) ;
  w_rename _  _ (NegPR k)     _ f := NegPR (w_rename _ _ k _ f) ;
  w_rename _  _ (NegPL c)     _ f := NegPL (s_rename _ c _ (r_shift1 f)) ;
  w_rename _  _ (NegNR c)     _ f := NegNR (s_rename _ c _ (r_shift1 f)) ;
  w_rename _  _ (NegNL v)     _ f := NegNL (w_rename _ _ v _ f) ;
with s_rename : state ⇒₀ ⟦ c_var , state ⟧₀ :=
  s_rename _ (Cut _ v k) _ f := Cut _ (t_rename _ _ v _ f) (t_rename _ _ k _ f) .

We extend it to values...

Equations v_rename : val ⇒₁ ⟦ c_var , val ⟧₁ :=
  v_rename _ (@LTy pos a) := w_rename _ _ ;
  v_rename _ (@RTy pos a) := t_rename _ _ ;
  v_rename _ (@LTy neg a) := t_rename _ _ ;
  v_rename _ (@RTy neg a) := w_rename _ _ .

... provide a couple infix notations...

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).

... and extend it to assignments.

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.

The following bunch of shifting functions will help us define parallel substitution.

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

We also define two embeddings linking the various syntactical categories.

Equations v_of_w Γ A : whn Γ A -> val Γ A :=
  v_of_w _ (@LTy pos _) v := v ;
  v_of_w _ (@RTy pos _) u := Whn u ;
  v_of_w _ (@LTy neg _) u := Whn u ;
  v_of_w _ (@RTy neg _) k := k .
Arguments v_of_w {Γ A} v.
#[global] Coercion v_of_w : whn >-> val.

Equations t_of_v Γ A : val Γ A -> term Γ A :=
  t_of_v _ (@LTy pos _) v := Whn v ;
  t_of_v _ (@RTy pos _) u := u ;
  t_of_v _ (@LTy neg _) u := u ;
  t_of_v _ (@RTy neg _) k := Whn k .
Arguments t_of_v {Γ A} v.
#[global] Coercion t_of_v : val >-> term.

Substitution

Having done with renaming, we reapply the same pattern to define parallel substitution. Note that substituting a weak head-normal form with values may not yield a weak head-normal form, but only a value!

Equations t_subst : term ⇒₁ ⟦ val , term ⟧₁ :=
  t_subst _ _ (Mu c)    _ f := Mu (s_subst _ c _ (a_shift1 f)) ;
  t_subst _ _ (RecL t)  _ f := RecL (t_subst _ _ t _ (a_shift1 f)) ;
  t_subst _ _ (RecR t)  _ f := RecR (t_subst _ _ t _ (a_shift1 f)) ;
  t_subst _ _ (Whn v)   _ f := w_subst _ _ v _ f ;
with w_subst : whn ⇒₁ ⟦ val , val ⟧₁ :=
  w_subst _  _ (Var i)      _ f := f _ i ;
  w_subst _  _ (ZerL)       _ f := Whn ZerL ;
  w_subst _  _ (TopR)       _ f := Whn TopR ;
  w_subst _  _ (OneR)       _ f := OneR ;
  w_subst _  _ (OneL c)     _ f := Whn (OneL (s_subst _ c _ f)) ;
  w_subst _  _ (BotR c)     _ f := Whn (BotR (s_subst _ c _ f)) ;
  w_subst _  _ (BotL)       _ f := BotL ;
  w_subst _  _ (TenR v1 v2) _ f := TenR (w_subst _ _ v1 _ f) (w_subst _ _ v2 _ f) ;
  w_subst _  _ (TenL c)     _ f := Whn (TenL (s_subst _ c _ (a_shift2 f))) ;
  w_subst _  _ (ParR c)     _ f := Whn (ParR (s_subst _ c _ (a_shift2 f))) ;
  w_subst _  _ (ParL k1 k2) _ f := ParL (w_subst _ _ k1 _ f) (w_subst _ _ k2 _ f) ;
  w_subst _  _ (OrR1 v)     _ f := OrR1 (w_subst _ _ v _ f) ;
  w_subst _  _ (OrR2 v)     _ f := OrR2 (w_subst _ _ v _ f) ;
  w_subst _  _ (OrL c1 c2)  _ f := Whn (OrL (s_subst _ c1 _ (a_shift1 f))
                                            (s_subst _ c2 _ (a_shift1 f))) ;
  w_subst _  _ (AndR c1 c2) _ f := Whn (AndR (s_subst _ c1 _ (a_shift1 f))
                                             (s_subst _ c2 _ (a_shift1 f))) ;
  w_subst _  _ (AndL1 k)    _ f := AndL1 (w_subst _ _ k _ f) ;
  w_subst _  _ (AndL2 k)    _ f := AndL2 (w_subst _ _ k _ f) ;
  w_subst _  _ (ShiftPR t)  _ f := ShiftPR (t_subst _ _ t _ f) ;
  w_subst _  _ (ShiftPL c)  _ f := Whn (ShiftPL (s_subst _ c _ (a_shift1 f))) ;
  w_subst _  _ (ShiftNR c)  _ f := Whn (ShiftNR (s_subst _ c _ (a_shift1 f))) ;
  w_subst _  _ (ShiftNL t)  _ f := ShiftNL (t_subst _ _ t _ f) ;
  w_subst _  _ (NegPR k)    _ f := NegPR (w_subst _ _ k _ f) ;
  w_subst _  _ (NegPL c)    _ f := Whn (NegPL (s_subst _ c _ (a_shift1 f))) ;
  w_subst _  _ (NegNR c)    _ f := Whn (NegNR (s_subst _ c _ (a_shift1 f))) ;
  w_subst _  _ (NegNL v)    _ f := NegNL (w_subst _ _ v _ f) ;
with s_subst : state ⇒₀ ⟦ val , state ⟧₀ :=
   s_subst _ (Cut p v k) _ f := Cut p (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 _ (@LTy pos a) v _ f := v `ᵥ⊛ f ;
  v_subst _ (@RTy pos a) t _ f := t `ₜ⊛ f ;
  v_subst _ (@LTy neg a) t _ f := t `ₜ⊛ f ;
  v_subst _ (@RTy neg a) k _ f := k `ᵥ⊛ f .

With this in hand we can instanciate the relevant part of substitution monoid and module structures for values and states. This will provide us with the missing infix notations.

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

We now define helpers for substituting the top one or top two variables from a context.

Definition asgn1 {Γ a} (v : val Γ a) : (Γ ▶ₓ a) =[val]> Γ := [ var ,ₓ v ] .
Definition asgn2 {Γ a b} (v1 : val Γ a) (v2 : val Γ b) : (Γ ▶ₓ a ▶ₓ b) =[val]> Γ
  := [ [ var ,ₓ v1 ] ,ₓ v2 ].

Arguments asgn1 {_ _} & _.
Arguments asgn2 {_ _ _} & _ _.

Notation "₁[ v ]" := (asgn1 v).
Notation "₂[ v1 , v2 ]" := (asgn2 v1 v2).

Observations

When defining (co-)patterns, we will enforce a form of focalisation, where no negative variables are introduced. In this context, 'negative' is a new notion applying to side-annotated types, mixing both type polarity and side annotation: a side-annotated variable is positive iff it is a positive variable or a negative co-variable.

Equations is_neg : ty -> SProp :=
  is_neg (@LTy pos a) := sEmpty ;
  is_neg (@RTy pos a) := sUnit ;
  is_neg (@LTy neg a) := sUnit ;
  is_neg (@RTy neg a) := sEmpty .

We define negative types as a subset of types, and negative contexts as a subset of contexts. Our generic infrastructure for contexts and variables really shines here as the type of variables in a negative context is convertible to the type of variables in the underlying context. See Ctx/Subset.v.

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.

We can now define patterns...

Inductive pat : ty -> Type :=
| PVarP (A : pre_ty neg) : pat `+A
| PVarN (A : pre_ty pos) : pat `-A
| POne : pat `+1
| PBot : pat `-⊥
| PTen {A B} : pat `+A -> pat `+B -> pat `+(A ⊗ B)
| PPar {A B} : pat `-A -> pat `-B -> pat `-(A ⅋ B)
| POr1 {A B} : pat `+A -> pat `+(A ⊕ B)
| POr2 {A B} : pat `+B -> pat `+(A ⊕ B)
| PAnd1 {A B} : pat `-A -> pat `-(A & B)
| PAnd2 {A B} : pat `-B -> pat `-(A & B)
| PShiftP A : pat `+(↓ A)
| PShiftN A : pat `-(↑ A)
| PNegP {A} : pat `-A -> pat `+(⊖ A)
| PNegN {A} : pat `+A -> pat `-(¬ A)
.

... and their domain, i.e. the context they bind.

Equations p_dom {t} : pat t -> neg_ctx :=
  p_dom (PVarP A)    := ∅ₛ ▶ₛ {| sub_elt := `+A ; sub_prf := stt |} ;
  p_dom (PVarN A)    := ∅ₛ ▶ₛ {| sub_elt := `-A ; sub_prf := stt |} ;
  p_dom (POne)       := ∅ₛ ;
  p_dom (PBot)       := ∅ₛ ;
  p_dom (PTen p1 p2) := p_dom p1 +▶ₛ p_dom p2 ;
  p_dom (PPar p1 p2) := p_dom p1 +▶ₛ p_dom p2 ;
  p_dom (POr1 p)     := p_dom p ;
  p_dom (POr2 p)     := p_dom p ;
  p_dom (PAnd1 p)    := p_dom p ;
  p_dom (PAnd2 p)    := p_dom p ;
  p_dom (PShiftP A)  := ∅ₛ ▶ₛ {| sub_elt := `+A ; sub_prf := stt |} ;
  p_dom (PShiftN A)  := ∅ₛ ▶ₛ {| sub_elt := `-A ; sub_prf := stt |} ;
  p_dom (PNegP p)    := p_dom p ;
  p_dom (PNegN p)    := p_dom p .

We finally instanciate the observation structure. Note that our generic formalization mostly cares about 'observations', that is co-patterns. As such we instanciate observations by patterns at the dual type.

Definition obs_op : Oper ty neg_ctx :=
  {| o_op A := pat A† ; o_dom _ p := p_dom p |} .

Now come a rather tedious set of embeddings between syntactic categories related to patterns. We start by embedding patterns into weak head-normal forms.

Equations w_of_p {a} (p : pat a) : whn (p_dom p) a :=
  w_of_p (PVarP _)    := Var top ;
  w_of_p (PVarN _)    := Var top ;
  w_of_p (POne)       := OneR ;
  w_of_p (PBot)       := BotL ;
  w_of_p (PTen p1 p2) := TenR (w_of_p p1 `ᵥ⊛ᵣ r_cat_l) (w_of_p p2 `ᵥ⊛ᵣ r_cat_r) ;
  w_of_p (PPar p1 p2) := ParL (w_of_p p1 `ᵥ⊛ᵣ r_cat_l) (w_of_p p2 `ᵥ⊛ᵣ r_cat_r) ;
  w_of_p (POr1 p)     := OrR1 (w_of_p p) ;
  w_of_p (POr2 p)     := OrR2 (w_of_p p) ;
  w_of_p (PAnd1 p)    := AndL1 (w_of_p p) ;
  w_of_p (PAnd2 p)    := AndL2 (w_of_p p) ;
  w_of_p (PShiftP _)  := ShiftPR (Whn (Var top)) ;
  w_of_p (PShiftN _)  := ShiftNL (Whn (Var top)) ;
  w_of_p (PNegP p)    := NegPR (w_of_p p) ;
  w_of_p (PNegN p)    := NegNL (w_of_p p) .
#[global] Coercion w_of_p : pat >-> whn.

Now we explain how to split (some) weak head-normal forms into a pattern filled with values. I am sorry in advance for your CPU-cycles wasted to typechecking these quite hard dependent pattern matchings. We start off by two helpers for refuting impossible variables in negative context, which because of the use of SProp give trouble to Equations for deriving functional elimination principles if inlined.

Definition elim_var_p {Γ : neg_ctx} {A : pre_ty pos} {X : Type} : Γ ∋ `+A -> X
  := fun i => match s_prf i with end .

Definition elim_var_n {Γ : neg_ctx} {A : pre_ty neg} {X : Type} : Γ ∋ `-A -> X
  := fun i => match s_prf i with end .

Equations p_of_w_0p {Γ : neg_ctx} (A : pre_ty pos) : whn Γ `+A -> pat `+A :=
  p_of_w_0p (0)     (Var i)      := elim_var_p i ;
  p_of_w_0p (1)     (Var i)      := elim_var_p i ;
  p_of_w_0p (A ⊗ B) (Var i)      := elim_var_p i ;
  p_of_w_0p (A ⊕ B) (Var i)      := elim_var_p i ;
  p_of_w_0p (↓ A)   (Var i)      := elim_var_p i ;
  p_of_w_0p (⊖ A)   (Var i)      := elim_var_p i ;
  p_of_w_0p (1)     (OneR)       := POne ;
  p_of_w_0p (A ⊗ B) (TenR v1 v2) := PTen (p_of_w_0p A v1) (p_of_w_0p B v2) ;
  p_of_w_0p (A ⊕ B) (OrR1 v)     := POr1 (p_of_w_0p A v) ;
  p_of_w_0p (A ⊕ B) (OrR2 v)     := POr2 (p_of_w_0p B v) ;
  p_of_w_0p (↓ A)   (ShiftPR _)  := PShiftP A ;
  p_of_w_0p (⊖ A)   (NegPR k)    := PNegP (p_of_w_0n A k) ;
with p_of_w_0n {Γ : neg_ctx} (A : pre_ty neg) : whn Γ `-A -> pat `-A :=
  p_of_w_0n (⊤)     (Var i)      := elim_var_n i ;
  p_of_w_0n (⊥)     (Var i)      := elim_var_n i ;
  p_of_w_0n (A ⅋ B) (Var i)      := elim_var_n i ;
  p_of_w_0n (A & B) (Var i)      := elim_var_n i ;
  p_of_w_0n (↑ A)   (Var i)      := elim_var_n i ;
  p_of_w_0n (¬ A)   (Var i)      := elim_var_n i ;
  p_of_w_0n (⊥)     (BotL)       := PBot ;
  p_of_w_0n (A ⅋ B) (ParL k1 k2) := PPar (p_of_w_0n A k1) (p_of_w_0n B k2) ;
  p_of_w_0n (A & B) (AndL1 k)    := PAnd1 (p_of_w_0n A k) ;
  p_of_w_0n (A & B) (AndL2 k)    := PAnd2 (p_of_w_0n B k) ;
  p_of_w_0n (↑ A)   (ShiftNL _)  := PShiftN A ;
  p_of_w_0n (¬ A)   (NegNL v)    := PNegN (p_of_w_0p A v) .

Equations p_dom_of_w_0p {Γ : neg_ctx} (A : pre_ty pos) (v : whn Γ `+A)
          : p_dom (p_of_w_0p A v) =[val]> Γ by struct A :=
  p_dom_of_w_0p (0)     (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (1)     (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (A ⊗ B) (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (A ⊕ B) (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (↓ A)   (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (⊖ A)   (Var i)      := elim_var_p i ;
  p_dom_of_w_0p (1)     (OneR)       := a_empty ;
  p_dom_of_w_0p (A ⊗ B) (TenR v1 v2) := [ p_dom_of_w_0p A v1 , p_dom_of_w_0p B v2 ] ;
  p_dom_of_w_0p (A ⊕ B) (OrR1 v)     := p_dom_of_w_0p A v ;
  p_dom_of_w_0p (A ⊕ B) (OrR2 v)     := p_dom_of_w_0p B v ;
  p_dom_of_w_0p (↓ A)   (ShiftPR x)  := a_append a_empty x ;
  p_dom_of_w_0p (⊖ A)   (NegPR k)    := p_dom_of_w_0n A k ;
     with p_dom_of_w_0n {Γ : neg_ctx} (A : pre_ty neg) (k : whn Γ `-A)
          : p_dom (p_of_w_0n A k) =[val]> Γ by struct A :=
  p_dom_of_w_0n (⊤)     (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (⊥)     (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (A ⅋ B) (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (A & B) (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (↑ A)   (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (¬ A)   (Var i)      := elim_var_n i ;
  p_dom_of_w_0n (⊥)     (BotL)       := a_empty ;
  p_dom_of_w_0n (A ⅋ B) (ParL k1 k2) := [ p_dom_of_w_0n A k1 , p_dom_of_w_0n B k2 ] ;
  p_dom_of_w_0n (A & B) (AndL1 k)    := p_dom_of_w_0n A k ;
  p_dom_of_w_0n (A & B) (AndL2 k)    := p_dom_of_w_0n B k ;
  p_dom_of_w_0n (↑ A)   (ShiftNL x)  := a_append a_empty x ;
  p_dom_of_w_0n (¬ A)   (NegNL v)    := p_dom_of_w_0p A v .

We can now package up all these auxiliary functions into the following ones, abstracting polarity and side-annotation.

Equations p_of_v {Γ : neg_ctx} A : val Γ A -> pat A :=
  p_of_v (@LTy pos A) v := p_of_w_0p A v ;
  p_of_v (@RTy pos A) _ := PVarN A ;
  p_of_v (@LTy neg A) _ := PVarP A ;
  p_of_v (@RTy neg A) k := p_of_w_0n A k .

Equations p_dom_of_v {Γ : neg_ctx} A (v : val Γ A) : p_dom (p_of_v A v) =[val]> Γ :=
  p_dom_of_v (@LTy pos A) v := p_dom_of_w_0p A v ;
  p_dom_of_v (@RTy pos A) x := [ ! ,ₓ x ] ;
  p_dom_of_v (@LTy neg A) x := [ ! ,ₓ x ] ;
  p_dom_of_v (@RTy neg A) k := p_dom_of_w_0n A k .

Definition v_split_p {Γ : neg_ctx} {A} (v : whn Γ `+A) : (obs_op # val) Γ `-A
  := (p_of_w_0p A v : o_op obs_op `-A) ⦇ p_dom_of_w_0p A v ⦈.

Definition v_split_n {Γ : neg_ctx} {A} (v : whn Γ `-A) : (obs_op # val) Γ `+A
  := (p_of_w_0n A v : o_op obs_op `+_) ⦇ p_dom_of_w_0n A v ⦈.

Evaluation

With patterns and observations now in hand we prepare for the definition of evaluation and define a shorthand for normal forms. 'Normal forms' are here understood---as in the paper---in our slightly non-standard presentation of triplets of a variable, an observation and an assignment.

Definition nf : Fam₀ ty neg_ctx := c_var ∥ₛ (obs_op # val).

Now the bulk of evaluation: the step function. Once again we are greatful for Equations providing us with a justification for the fact that this complex dependent pattern-matching is indeed total.

Equations eval_aux {Γ : neg_ctx} : state Γ -> (state Γ + nf Γ) :=
  eval_aux (Cut pos (Mu c)  (x))    := inl (c ₜ⊛ ₁[ x ]) ;
  eval_aux (Cut neg (x)     (Mu c)) := inl (c ₜ⊛ ₁[ x ]) ;

  eval_aux (Cut pos (Whn v) (Mu c))  := inl (c ₜ⊛ ₁[ v ]) ;
  eval_aux (Cut neg (Mu c)  (Whn k)) := inl (c ₜ⊛ ₁[ k ]) ;

  eval_aux (Cut pos (Whn v)  (RecL k)) := inl (Cut pos (Whn v) (k `ₜ⊛ ₁[ RecL k ])) ;
  eval_aux (Cut neg (RecR t) (Whn k))  := inl (Cut neg (t `ₜ⊛ ₁[ RecR t ]) (Whn k)) ;

  eval_aux (Cut pos (Whn v)       (Whn (Var i))) := inr (s_var_upg i ⋅ v_split_p v) ;
  eval_aux (Cut neg (Whn (Var i)) (Whn k))       := inr (s_var_upg i ⋅ v_split_n k) ;

  eval_aux (Cut pos (Whn (Var i)) (Whn _))       := elim_var_p i ;
  eval_aux (Cut neg (Whn _)       (Whn (Var i))) := elim_var_n i ;

  eval_aux (Cut pos (Whn (OneR))       (Whn (OneL c)))     := inl c ;
  eval_aux (Cut neg (Whn (BotR c))     (Whn (BotL)))       := inl c ;
  eval_aux (Cut pos (Whn (TenR v1 v2)) (Whn (TenL c)))     := inl (c ₜ⊛ ₂[ v1 , v2 ]) ;
  eval_aux (Cut neg (Whn (ParR c))     (Whn (ParL k1 k2))) := inl (c ₜ⊛ ₂[ k1 , k2 ]) ;
  eval_aux (Cut pos (Whn (OrR1 v))     (Whn (OrL c1 c2)))  := inl (c1 ₜ⊛ ₁[ v ]) ;
  eval_aux (Cut pos (Whn (OrR2 v))     (Whn (OrL c1 c2)))  := inl (c2 ₜ⊛ ₁[ v ]) ;
  eval_aux (Cut neg (Whn (AndR c1 c2)) (Whn (AndL1 k)))    := inl (c1 ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut neg (Whn (AndR c1 c2)) (Whn (AndL2 k)))    := inl (c2 ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut pos (Whn (ShiftPR x))  (Whn (ShiftPL c)))  := inl (c ₜ⊛ ₁[ x ]) ;
  eval_aux (Cut neg (Whn (ShiftNR c))  (Whn (ShiftNL x)))  := inl (c ₜ⊛ ₁[ x ]) ;
  eval_aux (Cut pos (Whn (NegPR k))    (Whn (NegPL c)))    := inl (c ₜ⊛ ₁[ k ]) ;
  eval_aux (Cut neg (Whn (NegNR c))    (Whn (NegNL v)))    := inl (c ₜ⊛ ₁[ v ]) .

Finally we define evaluation as the iteration of the step function in the Delay monad, and also define application of an observation with arguments to a value.

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

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

Metatheory

Now comes a rather ugly part: the metatheory of our syntax. Comments will be rather more sparse. For a thorough explaination of its structure, see Examples/Lambda/CBLTyped.v. We will here be concerned with extensional equality preservation, identity and composition laws for renaming and substitution, and also refolding lemmas for splitting and embedding patterns. You are encouraged to just skip until line ~1300.

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
  (P_t : forall Γ A, term Γ A -> Prop)
  (P_w : forall Γ A, whn Γ A -> Prop)
  (P_s : forall Γ, state Γ -> Prop) :=
{
  ind_mu : forall Γ A s (H : P_s _ s), P_t Γ A (Mu s) ;
  ind_recp : forall Γ A t (H : P_t _ _ t), P_t Γ `-A (RecL t) ;
  ind_recn : forall Γ A t (H : P_t _ _ t), P_t Γ `+A (RecR t) ;
  ind_whn : forall Γ A w (H : P_w _ _ w), P_t Γ A (Whn w) ;
  ind_var : forall Γ A h, P_w Γ A (Var h) ;
  ind_zerl : forall Γ, P_w Γ `-0 ZerL ;
  ind_topr : forall Γ, P_w Γ `+⊤ TopR ;
  ind_oner : forall Γ, P_w Γ `+1 OneR ;
  ind_onel : forall Γ s, P_s Γ s -> P_w Γ `-1 (OneL s) ;
  ind_botr : forall Γ s, P_s Γ s -> P_w Γ `+⊥ (BotR s) ;
  ind_botl : forall Γ, P_w Γ `-⊥ BotL ;
  ind_tenr : forall Γ A B w1 (H1 : P_w _ _ w1) w2 (H2 : P_w _ _ w2), P_w Γ `+(A ⊗ B) (TenR w1 w2) ;
  ind_tenl : forall Γ A B s (H : P_s _ s), P_w Γ `-(A ⊗ B) (TenL s) ;
  ind_parr : forall Γ A B s (H : P_s _ s), P_w Γ `+(A ⅋ B) (ParR s) ;
  ind_parl : forall Γ A B w1 (H1 : P_w _ _ w1) w2 (H2 : P_w Γ `-B w2), P_w Γ `-(A ⅋ B) (ParL w1 w2) ;
  ind_orr1 : forall Γ A B w (H : P_w _ _ w), P_w Γ `+(A ⊕ B) (OrR1 w) ;
  ind_orr2 : forall Γ A B w (H : P_w _ _ w), P_w Γ `+(A ⊕ B) (OrR2 w) ;
  ind_orl : forall Γ A B s1 (H1 : P_s _ s1) s2 (H2 : P_s _ s2), P_w Γ `-(A ⊕ B) (OrL s1 s2) ;
  ind_andr : forall Γ A B s1 (H1 : P_s _ s1) s2 (H2 : P_s _ s2), P_w Γ `+(A & B) (AndR s1 s2) ;
  ind_andl1 : forall Γ A B w (H : P_w _ _ w), P_w Γ `-(A & B) (AndL1 w) ;
  ind_andl2 : forall Γ A B w (H : P_w _ _ w), P_w Γ `-(A & B) (AndL2 w) ;
  ind_shiftpr : forall Γ A t (H : P_t _ _ t), P_w Γ `+(↓ A) (ShiftPR t) ;
  ind_shiftpl : forall Γ A s (H : P_s _ s), P_w Γ `-(↓ A) (ShiftPL s) ;
  ind_shiftnr : forall Γ A s (H : P_s _ s), P_w Γ `+(↑ A) (ShiftNR s) ;
  ind_shiftnl : forall Γ A t (H : P_t _ _ t), P_w Γ `-(↑ A) (ShiftNL t) ;
  ind_negpr : forall Γ A w (H : P_w _ _ w), P_w Γ `+(⊖ A) (NegPR w) ;
  ind_negpl : forall Γ A s (H : P_s _ s), P_w Γ `-(⊖ A) (NegPL s) ;
  ind_negnr : forall Γ A s (H : P_s _ s), P_w Γ `+(¬ A) (NegNR s) ;
  ind_negnl : forall Γ A w (H : P_w _ _ w), P_w Γ `-(¬ A) (NegNL w) ;
  ind_cut : forall Γ p A t1 (H1 : P_t _ _ t1) t2 (H2 : P_t _ _ t2), P_s Γ (@Cut _ p A t1 t2)
} .

Lemma term_ind_mut P_t P_w P_s (H : syn_ind_args P_t P_w P_s) Γ A t : P_t Γ A t .P_t: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
P_w: forall (Γ : t_ctx) (A : ty), whn Γ A -> Prop
P_s: forall Γ : t_ctx, state Γ -> Prop
H: syn_ind_args P_t P_w P_s
Γ: t_ctx
A: ty
t: term Γ A
P_t Γ A t
  destruct H; now apply (term_mut P_t P_w P_s).
Qed.

Lemma whn_ind_mut P_t P_w P_s (H : syn_ind_args P_t P_w P_s) Γ A w : P_w Γ A w .P_t: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
P_w: forall (Γ : t_ctx) (A : ty), whn Γ A -> Prop
P_s: forall Γ : t_ctx, state Γ -> Prop
H: syn_ind_args P_t P_w P_s
Γ: t_ctx
A: ty
w: whn Γ A
P_w Γ A w
  destruct H; now apply (whn_mut P_t P_w P_s).
Qed.

Lemma state_ind_mut P_t P_w P_s (H : syn_ind_args P_t P_w P_s) Γ s : P_s Γ s .P_t: forall (Γ : t_ctx) (A : ty), term Γ A -> Prop
P_w: forall (Γ : t_ctx) (A : ty), whn Γ A -> Prop
P_s: forall Γ : t_ctx, state Γ -> Prop
H: syn_ind_args P_t P_w P_s
Γ: t_ctx
s: state Γ
P_s Γ s
  destruct H; now apply (state_mut P_t P_w P_s).
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 : ty) (s : state (Γ ▶ₓ A †)),
s_ren_proper_P (Γ ▶ₓ A †) s ->
t_ren_proper_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_ren_proper_P (Γ ▶ₓ `- A) `- A t ->
t_ren_proper_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_ren_proper_P (Γ ▶ₓ `+ A) `+ A t ->
t_ren_proper_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_ren_proper_P Γ A w -> t_ren_proper_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_ren_proper_P Γ A (Var h)
forall Γ : t_ctx, w_ren_proper_P Γ `- 0 ZerL
forall Γ : t_ctx, w_ren_proper_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_ren_proper_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_ren_proper_P Γ s -> w_ren_proper_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_ren_proper_P Γ s -> w_ren_proper_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_ren_proper_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_ren_proper_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_ren_proper_P Γ `+ B w2 ->
w_ren_proper_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_ren_proper_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_ren_proper_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_ren_proper_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_ren_proper_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_ren_proper_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_ren_proper_P Γ `- B w2 ->
w_ren_proper_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_ren_proper_P Γ `+ A w ->
w_ren_proper_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_ren_proper_P Γ `+ B w ->
w_ren_proper_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_ren_proper_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_ren_proper_P (Γ ▶ₓ `+ B) s2 ->
w_ren_proper_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_ren_proper_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_ren_proper_P (Γ ▶ₓ `- B) s2 ->
w_ren_proper_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_ren_proper_P Γ `- A w ->
w_ren_proper_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_ren_proper_P Γ `- B w ->
w_ren_proper_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_ren_proper_P Γ `+ A t ->
w_ren_proper_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_proper_P (Γ ▶ₓ `+ A) s ->
w_ren_proper_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_ren_proper_P (Γ ▶ₓ `- A) s ->
w_ren_proper_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_ren_proper_P Γ `- A t ->
w_ren_proper_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_ren_proper_P Γ `- A w ->
w_ren_proper_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_ren_proper_P (Γ ▶ₓ `- A) s ->
w_ren_proper_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_proper_P (Γ ▶ₓ `+ A) s ->
w_ren_proper_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_ren_proper_P Γ `+ A w ->
w_ren_proper_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_ren_proper_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_ren_proper_P Γ `- A t2 ->
s_ren_proper_P Γ (Cut p t1 t2)
  all: unfold t_ren_proper_P, w_ren_proper_P, s_ren_proper_P.forall (Γ : t_ctx) (A : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> RecL t ₜ⊛ᵣ f1 = RecL t ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> RecR t ₜ⊛ᵣ f1 = RecR t ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Whn w ₜ⊛ᵣ f1 = Whn w ₜ⊛ᵣ f2
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A) (Δ : t_ctx)
  (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Var h `ᵥ⊛ᵣ f1 = Var h `ᵥ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ZerL `ᵥ⊛ᵣ f1 = ZerL `ᵥ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> TopR `ᵥ⊛ᵣ f1 = TopR `ᵥ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> OneR `ᵥ⊛ᵣ f1 = OneR `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> OneL s `ᵥ⊛ᵣ f1 = OneL s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> BotR s `ᵥ⊛ᵣ f1 = BotR s `ᵥ⊛ᵣ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> BotL `ᵥ⊛ᵣ f1 = BotL `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w1 `ᵥ⊛ᵣ f1 = w1 `ᵥ⊛ᵣ f2) ->
forall w2 : whn Γ `+ B,
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w2 `ᵥ⊛ᵣ f1 = w2 `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> TenR w1 w2 `ᵥ⊛ᵣ f1 = TenR w1 w2 `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> TenL s `ᵥ⊛ᵣ f1 = TenL s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ParR s `ᵥ⊛ᵣ f1 = ParR s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w1 `ᵥ⊛ᵣ f1 = w1 `ᵥ⊛ᵣ f2) ->
forall w2 : whn Γ `- B,
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w2 `ᵥ⊛ᵣ f1 = w2 `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ParL w1 w2 `ᵥ⊛ᵣ f1 = ParL w1 w2 `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> OrR1 w `ᵥ⊛ᵣ f1 = OrR1 w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> OrR2 w `ᵥ⊛ᵣ f1 = OrR2 w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2) ->
forall s2 : state (Γ ▶ₓ `+ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) ⊆ Δ),
 f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> OrL s1 s2 `ᵥ⊛ᵣ f1 = OrL s1 s2 `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
 f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2) ->
forall s2 : state (Γ ▶ₓ `- B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) ⊆ Δ),
 f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> AndR s1 s2 `ᵥ⊛ᵣ f1 = AndR s1 s2 `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> AndL1 w `ᵥ⊛ᵣ f1 = AndL1 w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> AndL2 w `ᵥ⊛ᵣ f1 = AndL2 w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ShiftPR t `ᵥ⊛ᵣ f1 = ShiftPR t `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ShiftPL s `ᵥ⊛ᵣ f1 = ShiftPL s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ShiftNR s `ᵥ⊛ᵣ f1 = ShiftNR s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> ShiftNL t `ᵥ⊛ᵣ f1 = ShiftNL t `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> NegPR w `ᵥ⊛ᵣ f1 = NegPR w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> NegPL s `ᵥ⊛ᵣ f1 = NegPL s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
 f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> NegNR s `ᵥ⊛ᵣ f1 = NegNR s `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ᵣ f1 = w `ᵥ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> NegNL w `ᵥ⊛ᵣ f1 = NegNL w `ᵥ⊛ᵣ f2
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> t1 ₜ⊛ᵣ f1 = t1 ₜ⊛ᵣ f2) ->
forall t2 : term Γ `- A,
(forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
 f1 ≡ₐ f2 -> t2 ₜ⊛ᵣ f1 = t2 ₜ⊛ᵣ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ ⊆ Δ),
f1 ≡ₐ f2 -> Cut p t1 t2 ₛ⊛ᵣ f1 = Cut p t1 t2 ₛ⊛ᵣ f2
  all: intros; cbn; f_equal; eauto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
t ₜ⊛ᵣ r_shift1 f1 = t ₜ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
t ₜ⊛ᵣ r_shift1 f1 = t ₜ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: ty
h: Γ ∋ A
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
f1 A h = f2 A h
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift2 f1 = s ₛ⊛ᵣ r_shift2 f2
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
s ₛ⊛ᵣ r_shift2 f1 = s ₛ⊛ᵣ r_shift2 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
s1 ₛ⊛ᵣ r_shift1 f1 = s1 ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
s2 ₛ⊛ᵣ r_shift1 f1 = s2 ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
s1 ₛ⊛ᵣ r_shift1 f1 = s1 ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
s2 ₛ⊛ᵣ r_shift1 f1 = s2 ₛ⊛ᵣ r_shift1 f2
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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
  all: first [ apply H | apply H1 | apply H2 ]; auto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> t ₜ⊛ᵣ f1 = t ₜ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift2 f1 ≡ₐ r_shift2 f2
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s ₛ⊛ᵣ f1 = s ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H0: f1 ≡ₐ f2
r_shift2 f1 ≡ₐ r_shift2 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) ⊆ Δ),
f1 ≡ₐ f2 -> s1 ₛ⊛ᵣ f1 = s1 ₛ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) ⊆ Δ),
f1 ≡ₐ f2 -> s2 ₛ⊛ᵣ f1 = s2 ₛ⊛ᵣ f2
Δ: t_ctx
f1, f2: Γ ⊆ Δ
H: f1 ≡ₐ f2
r_shift1 f1 ≡ₐ r_shift1 f2
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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
  all: first [ apply r_shift1_eq | apply r_shift2_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: 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 as [ [] | [] ].Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `+ p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `+ p v Δ)
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
  now apply w_ren_eq.Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `+ p v Δ)
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
  now apply t_ren_eq.Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
  now apply t_ren_eq.Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_rename Γ `- p v Δ)
  now apply w_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 (y:=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_shift2_eq {Γ Δ A B} : Proper (asgn_eq _ _ ==> asgn_eq _ _) (@a_shift2 Γ Δ A B).Γ, Δ: t_ctx
A, B: ty
Proper
  (asgn_eq Γ Δ ==> asgn_eq (Γ ▶ₓ A ▶ₓ B) (Δ ▶ₓ A ▶ₓ B))
  (a_shift2 (z:=B))
  intros ? ? H ? v.Γ, Δ: t_ctx
A, B: ty
x, y: Γ =[ val ]> Δ
H: x ≡ₐ y
a: ty
v: Γ ▶ₓ A ▶ₓ B ∋ a
a_shift2 x a v = a_shift2 y a v
  do 2 (dependent elimination v; auto).Γ1: ctx ty
Δ: t_ctx
y1, y0: ty
x, y: Γ1 =[ val ]> Δ
H: x ≡ₐ y
a: ty
v: Ctx.var a Γ1
a_shift2 x a (pop (pop v)) =
a_shift2 y a (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 : ty) (s : state (Γ ▶ₓ A †)),
s_ren_ren_P (Γ ▶ₓ A †) s -> t_ren_ren_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_ren_ren_P (Γ ▶ₓ `- A) `- A t ->
t_ren_ren_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_ren_ren_P (Γ ▶ₓ `+ A) `+ A t ->
t_ren_ren_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_ren_ren_P Γ A w -> t_ren_ren_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_ren_ren_P Γ A (Var h)
forall Γ : t_ctx, w_ren_ren_P Γ `- 0 ZerL
forall Γ : t_ctx, w_ren_ren_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_ren_ren_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_ren_ren_P Γ s -> w_ren_ren_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_ren_ren_P Γ s -> w_ren_ren_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_ren_ren_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_ren_ren_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_ren_ren_P Γ `+ B w2 ->
w_ren_ren_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_ren_ren_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_ren_ren_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_ren_ren_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_ren_ren_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_ren_ren_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_ren_ren_P Γ `- B w2 ->
w_ren_ren_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_ren_ren_P Γ `+ A w ->
w_ren_ren_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_ren_ren_P Γ `+ B w ->
w_ren_ren_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_ren_ren_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_ren_ren_P (Γ ▶ₓ `+ B) s2 ->
w_ren_ren_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_ren_ren_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_ren_ren_P (Γ ▶ₓ `- B) s2 ->
w_ren_ren_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_ren_ren_P Γ `- A w ->
w_ren_ren_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_ren_ren_P Γ `- B w ->
w_ren_ren_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_ren_ren_P Γ `+ A t ->
w_ren_ren_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_ren_P (Γ ▶ₓ `+ A) s ->
w_ren_ren_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_ren_ren_P (Γ ▶ₓ `- A) s ->
w_ren_ren_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_ren_ren_P Γ `- A t ->
w_ren_ren_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_ren_ren_P Γ `- A w ->
w_ren_ren_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_ren_ren_P (Γ ▶ₓ `- A) s ->
w_ren_ren_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_ren_P (Γ ▶ₓ `+ A) s ->
w_ren_ren_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_ren_ren_P Γ `+ A w ->
w_ren_ren_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_ren_ren_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_ren_ren_P Γ `- A t2 -> s_ren_ren_P Γ (Cut p t1 t2)
  all: unfold t_ren_ren_P, w_ren_ren_P, s_ren_ren_P.forall (Γ : t_ctx) (A : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(RecL t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = RecL t ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(RecR t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = RecR t ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Whn w ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = Whn w ₜ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Var h `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = Var h `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(ZerL `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = ZerL `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(TopR `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = TopR `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(OneR `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = OneR `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(OneL s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = OneL s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(BotR s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = BotR s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(BotL `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = BotL `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w1 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall w2 : whn Γ `+ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(TenR w1 w2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
TenR w1 w2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(TenL s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = TenL s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(ParR s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = ParR s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w1 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall w2 : whn Γ `- B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(ParL w1 w2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
ParL w1 w2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(OrR1 w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = OrR1 w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(OrR2 w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = OrR2 w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall s2 : state (Γ ▶ₓ `+ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(OrL s1 s2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
OrL s1 s2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall s2 : state (Γ ▶ₓ `- B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(AndR s1 s2 `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
AndR s1 s2 `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(AndL1 w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = AndL1 w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(AndL2 w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = AndL2 w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(ShiftPR t `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
ShiftPR t `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
(ShiftPL s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
ShiftPL s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
(ShiftNR s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
ShiftNR s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (t ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(ShiftNL t `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 =
ShiftNL t `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(NegPR w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = NegPR w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
(NegPL s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = NegPL s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
(NegNR s `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = NegNR s `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(NegNL w `ᵥ⊛ᵣ f1) `ᵥ⊛ᵣ f2 = NegNL w `ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (t1 ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t1 ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall t2 : term Γ `- A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
 (t2 ₜ⊛ᵣ f1) ₜ⊛ᵣ f2 = t2 ₜ⊛ᵣ (f1 ᵣ⊛ f2)) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(Cut p t1 t2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 =
Cut p t1 t2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
  all: intros; cbn; f_equal; eauto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ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: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ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 pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift2 f1) ₛ⊛ᵣ r_shift2 f2 =
s ₛ⊛ᵣ r_shift2 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Γ2) (f2 : Γ2 ⊆ Γ3),
(s ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s ₛ⊛ᵣ r_shift2 f1) ₛ⊛ᵣ r_shift2 f2 =
s ₛ⊛ᵣ r_shift2 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s1 ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s1 ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s2 ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s2 ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s1 ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s1 ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s1 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s1 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 ⊆ Γ3),
(s2 ₛ⊛ᵣ f1) ₛ⊛ᵣ f2 = s2 ₛ⊛ᵣ (f1 ᵣ⊛ f2)
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 ⊆ Γ3
(s2 ₛ⊛ᵣ r_shift1 f1) ₛ⊛ᵣ r_shift1 f2 =
s2 ₛ⊛ᵣ r_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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)
  all: first [ rewrite r_shift1_comp | rewrite r_shift2_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: 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 as [ [] | [] ].Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
v: val Γ1 `+ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
v: val Γ1 `+ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
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 neg
v: val Γ1 `+ p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply t_ren_ren.Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply t_ren_ren.Γ1, Γ2, Γ3: ctx ty
f1: Γ1 ⊆ Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
v: val Γ1 `- p
(v ᵥ⊛ᵣ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ᵣ (f1 ᵣ⊛ f2)
  now apply w_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 : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_ren_id_l_P (Γ ▶ₓ `- A) `- A t ->
t_ren_id_l_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_ren_id_l_P (Γ ▶ₓ `+ A) `+ A t ->
t_ren_id_l_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_ren_id_l_P Γ A w -> t_ren_id_l_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_ren_id_l_P Γ A (Var h)
forall Γ : t_ctx, w_ren_id_l_P Γ `- 0 ZerL
forall Γ : t_ctx, w_ren_id_l_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_ren_id_l_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_ren_id_l_P Γ s -> w_ren_id_l_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_ren_id_l_P Γ s -> w_ren_id_l_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_ren_id_l_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_ren_id_l_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_ren_id_l_P Γ `+ B w2 ->
w_ren_id_l_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_ren_id_l_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_ren_id_l_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_ren_id_l_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_ren_id_l_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_ren_id_l_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_ren_id_l_P Γ `- B w2 ->
w_ren_id_l_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_ren_id_l_P Γ `+ A w ->
w_ren_id_l_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_ren_id_l_P Γ `+ B w ->
w_ren_id_l_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_ren_id_l_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_ren_id_l_P (Γ ▶ₓ `+ B) s2 ->
w_ren_id_l_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_ren_id_l_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_ren_id_l_P (Γ ▶ₓ `- B) s2 ->
w_ren_id_l_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_ren_id_l_P Γ `- A w ->
w_ren_id_l_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_ren_id_l_P Γ `- B w ->
w_ren_id_l_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_ren_id_l_P Γ `+ A t ->
w_ren_id_l_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_id_l_P (Γ ▶ₓ `+ A) s ->
w_ren_id_l_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_ren_id_l_P (Γ ▶ₓ `- A) s ->
w_ren_id_l_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_ren_id_l_P Γ `- A t ->
w_ren_id_l_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_ren_id_l_P Γ `- A w ->
w_ren_id_l_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_ren_id_l_P (Γ ▶ₓ `- A) s ->
w_ren_id_l_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_id_l_P (Γ ▶ₓ `+ A) s ->
w_ren_id_l_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_ren_id_l_P Γ `+ A w ->
w_ren_id_l_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_ren_id_l_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_ren_id_l_P Γ `- A t2 -> s_ren_id_l_P Γ (Cut p t1 t2)
  all: unfold t_ren_id_l_P, w_ren_id_l_P, s_ren_id_l_P.forall (Γ : t_ctx) (A : ty) (s : state (Γ ▶ₓ A †)),
s ₛ⊛ᵣ r_id = s -> Mu s ₜ⊛ᵣ r_id = Mu s
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t ₜ⊛ᵣ r_id = t -> RecL t ₜ⊛ᵣ r_id = RecL t
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t ₜ⊛ᵣ r_id = t -> RecR t ₜ⊛ᵣ r_id = RecR t
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w `ᵥ⊛ᵣ r_id = w -> Whn w ₜ⊛ᵣ r_id = Whn w
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
Var h `ᵥ⊛ᵣ r_id = Var h
forall Γ : t_ctx, ZerL `ᵥ⊛ᵣ r_id = ZerL
forall Γ : t_ctx, TopR `ᵥ⊛ᵣ r_id = TopR
forall Γ : t_ctx, OneR `ᵥ⊛ᵣ r_id = OneR
forall (Γ : t_ctx) (s : state Γ),
s ₛ⊛ᵣ r_id = s -> OneL s `ᵥ⊛ᵣ r_id = OneL s
forall (Γ : t_ctx) (s : state Γ),
s ₛ⊛ᵣ r_id = s -> BotR s `ᵥ⊛ᵣ r_id = BotR s
forall Γ : t_ctx, BotL `ᵥ⊛ᵣ r_id = BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w1 `ᵥ⊛ᵣ r_id = w1 ->
forall w2 : whn Γ `+ B,
w2 `ᵥ⊛ᵣ r_id = w2 -> TenR w1 w2 `ᵥ⊛ᵣ r_id = TenR w1 w2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s ₛ⊛ᵣ r_id = s -> TenL s `ᵥ⊛ᵣ r_id = TenL s
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s ₛ⊛ᵣ r_id = s -> ParR s `ᵥ⊛ᵣ r_id = ParR s
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w1 `ᵥ⊛ᵣ r_id = w1 ->
forall w2 : whn Γ `- B,
w2 `ᵥ⊛ᵣ r_id = w2 -> ParL w1 w2 `ᵥ⊛ᵣ r_id = ParL w1 w2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w `ᵥ⊛ᵣ r_id = w -> OrR1 w `ᵥ⊛ᵣ r_id = OrR1 w
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w `ᵥ⊛ᵣ r_id = w -> OrR2 w `ᵥ⊛ᵣ r_id = OrR2 w
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s1 ₛ⊛ᵣ r_id = s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s2 ₛ⊛ᵣ r_id = s2 -> OrL s1 s2 `ᵥ⊛ᵣ r_id = OrL s1 s2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s1 ₛ⊛ᵣ r_id = s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s2 ₛ⊛ᵣ r_id = s2 -> AndR s1 s2 `ᵥ⊛ᵣ r_id = AndR s1 s2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w `ᵥ⊛ᵣ r_id = w -> AndL1 w `ᵥ⊛ᵣ r_id = AndL1 w
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w `ᵥ⊛ᵣ r_id = w -> AndL2 w `ᵥ⊛ᵣ r_id = AndL2 w
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t ₜ⊛ᵣ r_id = t -> ShiftPR t `ᵥ⊛ᵣ r_id = ShiftPR t
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s ₛ⊛ᵣ r_id = s -> ShiftPL s `ᵥ⊛ᵣ r_id = ShiftPL s
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s ₛ⊛ᵣ r_id = s -> ShiftNR s `ᵥ⊛ᵣ r_id = ShiftNR s
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t ₜ⊛ᵣ r_id = t -> ShiftNL t `ᵥ⊛ᵣ r_id = ShiftNL t
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w `ᵥ⊛ᵣ r_id = w -> NegPR w `ᵥ⊛ᵣ r_id = NegPR w
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s ₛ⊛ᵣ r_id = s -> NegPL s `ᵥ⊛ᵣ r_id = NegPL s
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s ₛ⊛ᵣ r_id = s -> NegNR s `ᵥ⊛ᵣ r_id = NegNR s
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w `ᵥ⊛ᵣ r_id = w -> NegNL w `ᵥ⊛ᵣ r_id = NegNL w
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t1 ₜ⊛ᵣ r_id = t1 ->
forall t2 : term Γ `- A,
t2 ₜ⊛ᵣ r_id = t2 -> Cut p t1 t2 ₛ⊛ᵣ r_id = Cut p t1 t2
  all: intros; cbn; f_equal; eauto.Γ: t_ctx
A: ty
s: state (Γ ▶ₓ A †)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: t ₜ⊛ᵣ r_id = t
t ₜ⊛ᵣ r_shift1 r_id = t
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: t ₜ⊛ᵣ r_id = t
t ₜ⊛ᵣ r_shift1 r_id = t
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift2 r_id = s
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift2 r_id = s
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₛ⊛ᵣ r_id = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₛ⊛ᵣ r_id = s2
s1 ₛ⊛ᵣ r_shift1 r_id = s1
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₛ⊛ᵣ r_id = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₛ⊛ᵣ r_id = s2
s2 ₛ⊛ᵣ r_shift1 r_id = s2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₛ⊛ᵣ r_id = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₛ⊛ᵣ r_id = s2
s1 ₛ⊛ᵣ r_shift1 r_id = s1
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₛ⊛ᵣ r_id = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₛ⊛ᵣ r_id = s2
s2 ₛ⊛ᵣ r_shift1 r_id = s2
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `+ A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `- A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `- A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `+ A)
H: s ₛ⊛ᵣ r_id = s
s ₛ⊛ᵣ r_shift1 r_id = s
  all: first [ rewrite r_shift1_id | rewrite r_shift2_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: 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 as [ [] | [] ].Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
  now apply w_ren_id_l.Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
  now apply t_ren_id_l.Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
  now apply t_ren_id_l.Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ᵣ r_id = v
  now apply w_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 as [ [] | [] ].
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_shift2_id {Γ A B} : @a_shift2 Γ Γ A B var ≡ₐ var.Γ: t_ctx
A, B: ty
a_shift2 var ≡ₐ var
  intros ? v; cbn.Γ: t_ctx
A, B, a: ty
v: Γ ▶ₓ A ▶ₓ B ∋ a
a_shift2 var a v =
match
  a as t
  return
    (cvar (Γ ▶ₓ A ▶ₓ B) t ->
     match t with
     | @LTy p p0 =>
         match p as p1 return (psh (pre_ty p1)) with
         | pos => whn (Γ ▶ₓ A ▶ₓ B) ∘ LTy
         | neg => term (Γ ▶ₓ A ▶ₓ B) ∘ LTy
         end p0
     | @RTy p p0 =>
         match p as p1 return (psh (pre_ty p1)) with
         | pos => term (Γ ▶ₓ A ▶ₓ B) ∘ RTy
         | neg => whn (Γ ▶ₓ A ▶ₓ B) ∘ RTy
         end p0
     end)
with
| @LTy p p0 =>
    fun c : cvar (Γ ▶ₓ A ▶ₓ B) `+ p0 =>
    match
      p as p1
      return
        (forall p2 : pre_ty p1,
         cvar (Γ ▶ₓ A ▶ₓ B) `+ p2 ->
         match p1 as p3 return (psh (pre_ty p3)) with
         | pos => whn (Γ ▶ₓ A ▶ₓ B) ∘ LTy
         | neg => term (Γ ▶ₓ A ▶ₓ B) ∘ LTy
         end p2)
    with
    | pos =>
        fun (p1 : pre_ty pos)
          (c0 : cvar (Γ ▶ₓ A ▶ₓ B) `+ p1) => Var c0
    | neg => fun p1 : pre_ty neg => Whn ∘ Var
    end p0 c
| @RTy p p0 =>
    fun c : cvar (Γ ▶ₓ A ▶ₓ B) `- p0 =>
    match
      p as p1
      return
        (forall p2 : pre_ty p1,
         cvar (Γ ▶ₓ A ▶ₓ B) `- p2 ->
         match p1 as p3 return (psh (pre_ty p3)) with
         | pos => term (Γ ▶ₓ A ▶ₓ B) ∘ RTy
         | neg => whn (Γ ▶ₓ A ▶ₓ B) ∘ RTy
         end p2)
    with
    | pos => fun p2 : pre_ty pos => Whn ∘ Var
    | neg =>
        fun (p2 : pre_ty neg)
          (c0 : cvar (Γ ▶ₓ A ▶ₓ B) `- p2) => Var c0
    end p0 c
end v
  do 2 (dependent elimination v; cbn; auto).Γ1: ctx ty
y0, y, a: ty
v: Ctx.var a Γ1
v_shift2 a
  (match
     a as t
     return
       (cvar Γ1 t ->
        match t with
        | @LTy p p0 =>
            match
              p as p1 return (psh (pre_ty p1))
            with
            | pos => whn Γ1 ∘ LTy
            | neg => term Γ1 ∘ LTy
            end p0
        | @RTy p p0 =>
            match
              p as p1 return (psh (pre_ty p1))
            with
            | pos => term Γ1 ∘ RTy
            | neg => whn Γ1 ∘ RTy
            end p0
        end)
   with
   | @LTy p p0 =>
       fun c : cvar Γ1 `+ p0 =>
       match
         p as p1
         return
           (forall p2 : pre_ty p1,
            cvar Γ1 `+ p2 ->
            match
              p1 as p3 return (psh (pre_ty p3))
            with
            | pos => whn Γ1 ∘ LTy
            | neg => term Γ1 ∘ LTy
            end p2)
       with
       | pos =>
           fun (p1 : pre_ty pos) (c0 : cvar Γ1 `+ p1)
           => Var c0
       | neg => fun p1 : pre_ty neg => Whn ∘ Var
       end p0 c
   | @RTy p p0 =>
       fun c : cvar Γ1 `- p0 =>
       match
         p as p1
         return
           (forall p2 : pre_ty p1,
            cvar Γ1 `- p2 ->
            match
              p1 as p3 return (psh (pre_ty p3))
            with
            | pos => term Γ1 ∘ RTy
            | neg => whn Γ1 ∘ RTy
            end p2)
       with
       | pos => fun p2 : pre_ty pos => Whn ∘ Var
       | neg =>
           fun (p2 : pre_ty neg) (c0 : cvar Γ1 `- p2)
           => Var c0
       end p0 c
   end v) =
match
  a as t
  return
    (cvar (Γ1 ▶ₓ y0 ▶ₓ y) t ->
     match t with
     | @LTy p p0 =>
         match p as p1 return (psh (pre_ty p1)) with
         | pos => whn (Γ1 ▶ₓ y0 ▶ₓ y) ∘ LTy
         | neg => term (Γ1 ▶ₓ y0 ▶ₓ y) ∘ LTy
         end p0
     | @RTy p p0 =>
         match p as p1 return (psh (pre_ty p1)) with
         | pos => term (Γ1 ▶ₓ y0 ▶ₓ y) ∘ RTy
         | neg => whn (Γ1 ▶ₓ y0 ▶ₓ y) ∘ RTy
         end p0
     end)
with
| @LTy p p0 =>
    fun c : cvar (Γ1 ▶ₓ y0 ▶ₓ y) `+ p0 =>
    match
      p as p1
      return
        (forall p2 : pre_ty p1,
         cvar (Γ1 ▶ₓ y0 ▶ₓ y) `+ p2 ->
         match p1 as p3 return (psh (pre_ty p3)) with
         | pos => whn (Γ1 ▶ₓ y0 ▶ₓ y) ∘ LTy
         | neg => term (Γ1 ▶ₓ y0 ▶ₓ y) ∘ LTy
         end p2)
    with
    | pos =>
        fun (p1 : pre_ty pos)
          (c0 : cvar (Γ1 ▶ₓ y0 ▶ₓ y) `+ p1) => Var c0
    | neg => fun p1 : pre_ty neg => Whn ∘ Var
    end p0 c
| @RTy p p0 =>
    fun c : cvar (Γ1 ▶ₓ y0 ▶ₓ y) `- p0 =>
    match
      p as p1
      return
        (forall p2 : pre_ty p1,
         cvar (Γ1 ▶ₓ y0 ▶ₓ y) `- p2 ->
         match p1 as p3 return (psh (pre_ty p3)) with
         | pos => term (Γ1 ▶ₓ y0 ▶ₓ y) ∘ RTy
         | neg => whn (Γ1 ▶ₓ y0 ▶ₓ y) ∘ RTy
         end p2)
    with
    | pos => fun p2 : pre_ty pos => Whn ∘ Var
    | neg =>
        fun (p2 : pre_ty neg)
          (c0 : cvar (Γ1 ▶ₓ y0 ▶ₓ y) `- p2) => Var c0
    end p0 c
end (pop (pop v))
  now destruct a as [[]|[]].
Qed.

Arguments var : simpl never.
Lemma a_shift1_ren_r {Γ1 Γ2 Γ3 y} (f1 : Γ1 =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3)
      : a_shift1 (y:=y) (f1 ⊛ᵣ f2) ≡ₐ a_shift1 f1 ⊛ᵣ r_shift1 f2 .Γ1, Γ2, Γ3: t_ctx
y: 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
y0: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: Ctx.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
y0: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: Ctx.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_shift2_ren_r {Γ1 Γ2 Γ3 y z} (f1 : Γ1 =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3)
      : a_shift2 (y:=y) (z:=z) (f1 ⊛ᵣ f2) ≡ₐ a_shift2 f1 ⊛ᵣ r_shift2 f2 .Γ1, Γ2, Γ3: t_ctx
y, z: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a_shift2 (f1 ⊛ᵣ f2) ≡ₐ a_shift2 f1 ⊛ᵣ r_shift2 f2
  intros ? v; do 2 (dependent elimination v; cbn; [ now rewrite v_ren_id_r | ]).Γ0: ctx ty
Γ2, Γ3: t_ctx
y1, y0: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
a: ty
v: Ctx.var a Γ0
v_shift2 a (f1 a v ᵥ⊛ᵣ f2) =
v_shift2 a (f1 a v) ᵥ⊛ᵣ r_shift2 f2
  unfold v_shift2; now rewrite 2 v_ren_ren.
Qed.

Lemma a_shift1_ren_l {Γ1 Γ2 Γ3 y} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3)
  : a_shift1 (y:=y) (f1 ᵣ⊛ f2) ≡ₐ r_shift1 f1 ᵣ⊛ a_shift1 f2 .Γ1, Γ2: ctx ty
Γ3: t_ctx
y: 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_shift2_ren_l {Γ1 Γ2 Γ3 y z} (f1 : Γ1 ⊆ Γ2) (f2 : Γ2 =[val]> Γ3)
      : a_shift2 (y:=y) (z:=z) (f1 ᵣ⊛ f2) ≡ₐ r_shift2 f1 ᵣ⊛ a_shift2 f2 .Γ1, Γ2: ctx ty
Γ3: t_ctx
y, z: ty
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
a_shift2 (f1 ᵣ⊛ f2) ≡ₐ r_shift2 f1 ᵣ⊛ a_shift2 f2
  intros ? v; do 2 (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 : ty) (s : state (Γ ▶ₓ A †)),
s_sub_proper_P (Γ ▶ₓ A †) s ->
t_sub_proper_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_sub_proper_P (Γ ▶ₓ `- A) `- A t ->
t_sub_proper_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_sub_proper_P (Γ ▶ₓ `+ A) `+ A t ->
t_sub_proper_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_sub_proper_P Γ A w -> t_sub_proper_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_sub_proper_P Γ A (Var h)
forall Γ : t_ctx, w_sub_proper_P Γ `- 0 ZerL
forall Γ : t_ctx, w_sub_proper_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_sub_proper_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_sub_proper_P Γ s -> w_sub_proper_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_sub_proper_P Γ s -> w_sub_proper_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_sub_proper_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_sub_proper_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_sub_proper_P Γ `+ B w2 ->
w_sub_proper_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_sub_proper_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_sub_proper_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_sub_proper_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_sub_proper_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_sub_proper_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_sub_proper_P Γ `- B w2 ->
w_sub_proper_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_sub_proper_P Γ `+ A w ->
w_sub_proper_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_sub_proper_P Γ `+ B w ->
w_sub_proper_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_sub_proper_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_sub_proper_P (Γ ▶ₓ `+ B) s2 ->
w_sub_proper_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_sub_proper_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_sub_proper_P (Γ ▶ₓ `- B) s2 ->
w_sub_proper_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_sub_proper_P Γ `- A w ->
w_sub_proper_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_sub_proper_P Γ `- B w ->
w_sub_proper_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_sub_proper_P Γ `+ A t ->
w_sub_proper_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_proper_P (Γ ▶ₓ `+ A) s ->
w_sub_proper_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_sub_proper_P (Γ ▶ₓ `- A) s ->
w_sub_proper_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_sub_proper_P Γ `- A t ->
w_sub_proper_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_sub_proper_P Γ `- A w ->
w_sub_proper_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_sub_proper_P (Γ ▶ₓ `- A) s ->
w_sub_proper_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_proper_P (Γ ▶ₓ `+ A) s ->
w_sub_proper_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_sub_proper_P Γ `+ A w ->
w_sub_proper_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_sub_proper_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_sub_proper_P Γ `- A t2 ->
s_sub_proper_P Γ (Cut p t1 t2)
  all: unfold t_sub_proper_P, w_sub_proper_P, s_sub_proper_P.forall (Γ : t_ctx) (A : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> RecL t `ₜ⊛ f1 = RecL t `ₜ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> RecR t `ₜ⊛ f1 = RecR t `ₜ⊛ f2
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Whn w `ₜ⊛ f1 = Whn w `ₜ⊛ f2
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A) (Δ : t_ctx)
  (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Var h `ᵥ⊛ f1 = Var h `ᵥ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ZerL `ᵥ⊛ f1 = ZerL `ᵥ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> TopR `ᵥ⊛ f1 = TopR `ᵥ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> OneR `ᵥ⊛ f1 = OneR `ᵥ⊛ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> OneL s `ᵥ⊛ f1 = OneL s `ᵥ⊛ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> BotR s `ᵥ⊛ f1 = BotR s `ᵥ⊛ f2
forall (Γ Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> BotL `ᵥ⊛ f1 = BotL `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2) ->
forall w2 : whn Γ `+ B,
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> TenR w1 w2 `ᵥ⊛ f1 = TenR w1 w2 `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
(forall (Δ : t_ctx)
   (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> TenL s `ᵥ⊛ f1 = TenL s `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
(forall (Δ : t_ctx)
   (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ParR s `ᵥ⊛ f1 = ParR s `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2) ->
forall w2 : whn Γ `- B,
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ParL w1 w2 `ᵥ⊛ f1 = ParL w1 w2 `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> OrR1 w `ᵥ⊛ f1 = OrR1 w `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> OrR2 w `ᵥ⊛ f1 = OrR2 w `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2) ->
forall s2 : state (Γ ▶ₓ `+ B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> OrL s1 s2 `ᵥ⊛ f1 = OrL s1 s2 `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2) ->
forall s2 : state (Γ ▶ₓ `- B),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> AndR s1 s2 `ᵥ⊛ f1 = AndR s1 s2 `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> AndL1 w `ᵥ⊛ f1 = AndL1 w `ᵥ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> AndL2 w `ᵥ⊛ f1 = AndL2 w `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ShiftPR t `ᵥ⊛ f1 = ShiftPR t `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ShiftPL s `ᵥ⊛ f1 = ShiftPL s `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ShiftNR s `ᵥ⊛ f1 = ShiftNR s `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> ShiftNL t `ᵥ⊛ f1 = ShiftNL t `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> NegPR w `ᵥ⊛ f1 = NegPR w `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> NegPL s `ᵥ⊛ f1 = NegPL s `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
(forall (Δ : t_ctx) (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
 f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> NegNR s `ᵥ⊛ f1 = NegNR s `ᵥ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> NegNL w `ᵥ⊛ f1 = NegNL w `ᵥ⊛ f2
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> t1 `ₜ⊛ f1 = t1 `ₜ⊛ f2) ->
forall t2 : term Γ `- A,
(forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
 f1 ≡ₐ f2 -> t2 `ₜ⊛ f1 = t2 `ₜ⊛ f2) ->
forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> Cut p t1 t2 ₜ⊛ f1 = Cut p t1 t2 ₜ⊛ f2
  all: intros; cbn.Γ: t_ctx
A: 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
Mu (s_subst (Γ ▶ₓ A †) s (Δ ▶ₓ A †) (a_shift1 f1)) =
Mu (s_subst (Γ ▶ₓ A †) s (Δ ▶ₓ A †) (a_shift1 f2))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
RecL (t `ₜ⊛ a_shift1 f1) = RecL (t `ₜ⊛ a_shift1 f2)
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
RecR (t `ₜ⊛ a_shift1 f1) = RecR (t `ₜ⊛ a_shift1 f2)
Γ: t_ctx
A: ty
w: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A: ty
h: Γ ∋ A
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
f1 A h = f2 A h
Γ, Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
Whn ZerL = Whn ZerL
Γ, Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
Whn TopR = Whn TopR
Γ, Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
Whn (OneL (s_subst Γ s Δ f1)) =
Whn (OneL (s_subst Γ s Δ f2))
Γ: t_ctx
s: state Γ
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
Whn (BotR (s_subst Γ s Δ f1)) =
Whn (BotR (s_subst Γ s Δ f2))
Γ, Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `+ B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
TenR (w1 `ᵥ⊛ f1) (w2 `ᵥ⊛ f1) =
TenR (w1 `ᵥ⊛ f2) (w2 `ᵥ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Δ ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f1))) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Δ ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2)))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Δ ▶ₓ `- A ▶ₓ `- B) (a_shift2 f1))) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Δ ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2)))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `- B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
ParL (w1 `ᵥ⊛ f1) (w2 `ᵥ⊛ f1) =
ParL (w1 `ᵥ⊛ f2) (w2 `ᵥ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
OrR1 (w `ᵥ⊛ f1) = OrR1 (w `ᵥ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
OrR2 (w `ᵥ⊛ f1) = OrR2 (w `ᵥ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Δ ▶ₓ `+ A) (a_shift1 f1))
     (s_subst (Γ ▶ₓ `+ B) s2 (Δ ▶ₓ `+ B) (a_shift1 f1))) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Δ ▶ₓ `+ A) (a_shift1 f2))
     (s_subst (Γ ▶ₓ `+ B) s2 (Δ ▶ₓ `+ B) (a_shift1 f2)))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Δ ▶ₓ `- A) (a_shift1 f1))
     (s_subst (Γ ▶ₓ `- B) s2 (Δ ▶ₓ `- B) (a_shift1 f1))) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Δ ▶ₓ `- A) (a_shift1 f2))
     (s_subst (Γ ▶ₓ `- B) s2 (Δ ▶ₓ `- B) (a_shift1 f2)))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
AndL1 (w `ᵥ⊛ f1) = AndL1 (w `ᵥ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
AndL2 (w `ᵥ⊛ f1) = AndL2 (w `ᵥ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
ShiftPR (t `ₜ⊛ f1) = ShiftPR (t `ₜ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Δ ▶ₓ `+ A) (a_shift1 f1))) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Δ ▶ₓ `+ A) (a_shift1 f2)))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Δ ▶ₓ `- A) (a_shift1 f1))) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Δ ▶ₓ `- A) (a_shift1 f2)))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
ShiftNL (t `ₜ⊛ f1) = ShiftNL (t `ₜ⊛ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
NegPR (w `ᵥ⊛ f1) = NegPR (w `ᵥ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Δ ▶ₓ `- A) (a_shift1 f1))) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Δ ▶ₓ `- A) (a_shift1 f2)))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Δ ▶ₓ `+ A) (a_shift1 f1))) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Δ ▶ₓ `+ A) (a_shift1 f2)))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
NegNL (w `ᵥ⊛ f1) = NegNL (w `ᵥ⊛ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t1 `ₜ⊛ f1 = t1 `ₜ⊛ f2
t2: term Γ `- A
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t2 `ₜ⊛ f1 = t2 `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
Cut p (t1 `ₜ⊛ f1) (t2 `ₜ⊛ f1) =
Cut p (t1 `ₜ⊛ f2) (t2 `ₜ⊛ f2)
  all: match goal with
       | |- Whn _ = Whn _ => do 2 f_equal
       | _ => f_equal
       end .Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
t `ₜ⊛ a_shift1 f1 = t `ₜ⊛ a_shift1 f2
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
t `ₜ⊛ a_shift1 f1 = t `ₜ⊛ a_shift1 f2
Γ: t_ctx
A: ty
w: whn Γ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
s: state Γ
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst Γ s Δ f1 = s_subst Γ s Δ f2
Γ: t_ctx
s: state Γ
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst Γ s Δ f1 = s_subst Γ s Δ f2
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `+ B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `+ B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Δ ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 f1) =
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Δ ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 f2)
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Δ ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 f1) =
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Δ ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 f2)
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `- B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w1 `ᵥ⊛ f1 = w1 `ᵥ⊛ f2
w2: whn Γ `- B
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
w2 `ᵥ⊛ f1 = w2 `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `+ A) s1 (Δ ▶ₓ `+ A) (a_shift1 f1) =
s_subst (Γ ▶ₓ `+ A) s1 (Δ ▶ₓ `+ A) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `+ B) s2 (Δ ▶ₓ `+ B) (a_shift1 f1) =
s_subst (Γ ▶ₓ `+ B) s2 (Δ ▶ₓ `+ B) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `- A) s1 (Δ ▶ₓ `- A) (a_shift1 f1) =
s_subst (Γ ▶ₓ `- A) s1 (Δ ▶ₓ `- A) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
s_subst (Γ ▶ₓ `- B) s2 (Δ ▶ₓ `- B) (a_shift1 f1) =
s_subst (Γ ▶ₓ `- B) s2 (Δ ▶ₓ `- B) (a_shift1 f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
t `ₜ⊛ f1 = t `ₜ⊛ f2
Γ: t_ctx
A: pre_ty neg
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 pos
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 pos
t: term Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
t `ₜ⊛ f1 = t `ₜ⊛ f2
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
A: pre_ty neg
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 pos
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 pos
w: whn Γ `+ A
H: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
w `ᵥ⊛ f1 = w `ᵥ⊛ f2
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t1 `ₜ⊛ f1 = t1 `ₜ⊛ f2
t2: term Γ `- A
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t2 `ₜ⊛ f1 = t2 `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
t1 `ₜ⊛ f1 = t1 `ₜ⊛ f2
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t1 `ₜ⊛ f1 = t1 `ₜ⊛ f2
t2: term Γ `- A
H2: forall (Δ : t_ctx) (f1 f2 : Γ =[ val ]> Δ),
f1 ≡ₐ f2 -> t2 `ₜ⊛ f1 = t2 `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
t2 `ₜ⊛ f1 = t2 `ₜ⊛ f2
  all: first [ apply H | apply H1 | apply H2 ]; auto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> t `ₜ⊛ f1 = t `ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift2 f1 ≡ₐ a_shift2 f2
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s ₜ⊛ f1 = s ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H0: f1 ≡ₐ f2
a_shift2 f1 ≡ₐ a_shift2 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `+ B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- A) =[ val ]> Δ),
f1 ≡ₐ f2 -> s1 ₜ⊛ f1 = s1 ₜ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Δ : t_ctx)
  (f1 f2 : (Γ ▶ₓ `- B) =[ val ]> Δ),
f1 ≡ₐ f2 -> s2 ₜ⊛ f1 = s2 ₜ⊛ f2
Δ: t_ctx
f1, f2: Γ =[ val ]> Δ
H: f1 ≡ₐ f2
a_shift1 f1 ≡ₐ a_shift1 f2
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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
  all: first [ apply a_shift1_eq | apply a_shift2_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: 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 as [[]|[]].Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `+ p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `+ p v Δ)
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `- p v Δ)
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `- p v Δ)
  -Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `+ p v Δ) now apply w_sub_eq.
  -Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `+ p v Δ) now apply t_sub_eq.
  -Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `- p v Δ) now apply t_sub_eq.
  -Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
Δ: t_ctx
Proper (asgn_eq Γ Δ ==> eq) (v_subst Γ `- p v Δ) now apply w_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 : ty) (s : state (Γ ▶ₓ A †)),
s_ren_sub_P (Γ ▶ₓ A †) s -> t_ren_sub_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_ren_sub_P (Γ ▶ₓ `- A) `- A t ->
t_ren_sub_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_ren_sub_P (Γ ▶ₓ `+ A) `+ A t ->
t_ren_sub_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_ren_sub_P Γ A w -> t_ren_sub_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_ren_sub_P Γ A (Var h)
forall Γ : t_ctx, w_ren_sub_P Γ `- 0 ZerL
forall Γ : t_ctx, w_ren_sub_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_ren_sub_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_ren_sub_P Γ s -> w_ren_sub_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_ren_sub_P Γ s -> w_ren_sub_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_ren_sub_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_ren_sub_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_ren_sub_P Γ `+ B w2 ->
w_ren_sub_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_ren_sub_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_ren_sub_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_ren_sub_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_ren_sub_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_ren_sub_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_ren_sub_P Γ `- B w2 ->
w_ren_sub_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_ren_sub_P Γ `+ A w ->
w_ren_sub_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_ren_sub_P Γ `+ B w ->
w_ren_sub_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_ren_sub_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_ren_sub_P (Γ ▶ₓ `+ B) s2 ->
w_ren_sub_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_ren_sub_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_ren_sub_P (Γ ▶ₓ `- B) s2 ->
w_ren_sub_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_ren_sub_P Γ `- A w ->
w_ren_sub_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_ren_sub_P Γ `- B w ->
w_ren_sub_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_ren_sub_P Γ `+ A t ->
w_ren_sub_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_sub_P (Γ ▶ₓ `+ A) s ->
w_ren_sub_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_ren_sub_P (Γ ▶ₓ `- A) s ->
w_ren_sub_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_ren_sub_P Γ `- A t ->
w_ren_sub_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_ren_sub_P Γ `- A w ->
w_ren_sub_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_ren_sub_P (Γ ▶ₓ `- A) s ->
w_ren_sub_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_ren_sub_P (Γ ▶ₓ `+ A) s ->
w_ren_sub_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_ren_sub_P Γ `+ A w ->
w_ren_sub_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_ren_sub_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_ren_sub_P Γ `- A t2 -> s_ren_sub_P Γ (Cut p t1 t2)
  all: unfold t_ren_sub_P, w_ren_sub_P, s_ren_sub_P.forall (Γ : t_ctx) (A : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(RecL t `ₜ⊛ f1) ₜ⊛ᵣ f2 = RecL t `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(RecR t `ₜ⊛ f1) ₜ⊛ᵣ f2 = RecR t `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Whn w `ₜ⊛ f1) ₜ⊛ᵣ f2 = Whn w `ₜ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(Var h `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = Var h `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(ZerL `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ZerL `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(TopR `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = TopR `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(OneR `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = OneR `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(OneL s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = OneL s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(BotR s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = BotR s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(BotL `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = BotL `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall w2 : whn Γ `+ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(TenR w1 w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = TenR w1 w2 `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(TenL s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = TenL s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(ParR s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ParR s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall w2 : whn Γ `- B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(ParL w1 w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ParL w1 w2 `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(OrR1 w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = OrR1 w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(OrR2 w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = OrR2 w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2) ->
forall s2 : state (Γ ▶ₓ `+ B),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(OrL s1 s2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = OrL s1 s2 `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2) ->
forall s2 : state (Γ ▶ₓ `- B),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
 (s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(AndR s1 s2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = AndR s1 s2 `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(AndL1 w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = AndL1 w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(AndL2 w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = AndL2 w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(ShiftPR t `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ShiftPR t `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
(ShiftPL s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ShiftPL s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
(ShiftNR s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ShiftNR s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(ShiftNL t `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = ShiftNL t `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(NegPR w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = NegPR w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
(NegPL s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = NegPL s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
(NegNR s `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = NegNR s `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3), (w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(NegNL w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = NegNL w `ᵥ⊛ f1 ⊛ᵣ f2
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t1 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t1 `ₜ⊛ f1 ⊛ᵣ f2) ->
forall t2 : term Γ `- A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
   (f2 : Γ2 ⊆ Γ3),
 (t2 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t2 `ₜ⊛ f1 ⊛ᵣ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(Cut p t1 t2 ₜ⊛ f1) ₛ⊛ᵣ f2 = Cut p t1 t2 ₜ⊛ f1 ⊛ᵣ f2
  all: intros; cbn.Γ: t_ctx
A: 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
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ2 ▶ₓ A †) (a_shift1 f1)
   ₛ⊛ᵣ r_shift1 f2) =
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ3 ▶ₓ A †)
     (a_shift1 (f1 ⊛ᵣ f2)))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
RecL ((t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2) =
RecL (t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
RecR ((t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2) =
RecR (t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A: ty
w: whn Γ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
(w `ᵥ⊛ f1) ₜ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ: t_ctx
A: ty
h: Γ ∋ A
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
f1 A h ᵥ⊛ᵣ f2 = f1 A h ᵥ⊛ᵣ f2
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn ZerL = Whn ZerL
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn TopR = Whn TopR
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn (OneL (s_subst Γ s Γ2 f1 ₛ⊛ᵣ f2)) =
Whn (OneL (s_subst Γ s Γ3 (f1 ⊛ᵣ f2)%asgn))
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn (BotR (s_subst Γ s Γ2 f1 ₛ⊛ᵣ f2)) =
Whn (BotR (s_subst Γ s Γ3 (f1 ⊛ᵣ f2)%asgn))
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2
w2: whn Γ `+ B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
TenR ((w1 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) =
TenR (w1 `ᵥ⊛ f1 ⊛ᵣ f2) (w2 `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ2 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f1)
      ₛ⊛ᵣ r_shift2 f2)) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ2 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f1)
      ₛ⊛ᵣ r_shift2 f2)) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2
w2: whn Γ `- B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ParL ((w1 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) =
ParL (w1 `ᵥ⊛ f1 ⊛ᵣ f2) (w2 `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OrR1 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = OrR1 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OrR2 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = OrR2 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2)))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)
     (s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2)))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
AndL1 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = AndL1 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
AndL2 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = AndL2 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ShiftPR ((t `ₜ⊛ f1) ₜ⊛ᵣ f2) = ShiftPR (t `ₜ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ShiftNL ((t `ₜ⊛ f1) ₜ⊛ᵣ f2) = ShiftNL (t `ₜ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
NegPR ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = NegPR (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
NegNL ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = NegNL (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t1 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t1 `ₜ⊛ f1 ⊛ᵣ f2
t2: term Γ `- A
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t2 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t2 `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Cut p ((t1 `ₜ⊛ f1) ₜ⊛ᵣ f2) ((t2 `ₜ⊛ f1) ₜ⊛ᵣ f2) =
Cut p (t1 `ₜ⊛ f1 ⊛ᵣ f2) (t2 `ₜ⊛ f1 ⊛ᵣ f2)
  4: destruct A as [ [] | [] ]; cbn.Γ: t_ctx
A: 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
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ2 ▶ₓ A †) (a_shift1 f1)
   ₛ⊛ᵣ r_shift1 f2) =
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ3 ▶ₓ A †)
     (a_shift1 (f1 ⊛ᵣ f2)))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
RecL ((t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2) =
RecL (t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
RecR ((t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2) =
RecR (t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
p: pre_ty pos
w: whn Γ `+ p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = Whn (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
p: pre_ty neg
w: whn Γ `+ p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
(w `ᵥ⊛ f1) ₜ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ: t_ctx
p: pre_ty pos
w: whn Γ `- p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
(w `ᵥ⊛ f1) ₜ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ: t_ctx
p: pre_ty neg
w: whn Γ `- p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = Whn (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: ty
h: Γ ∋ A
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
f1 A h ᵥ⊛ᵣ f2 = f1 A h ᵥ⊛ᵣ f2
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn ZerL = Whn ZerL
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn TopR = Whn TopR
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn (OneL (s_subst Γ s Γ2 f1 ₛ⊛ᵣ f2)) =
Whn (OneL (s_subst Γ s Γ3 (f1 ⊛ᵣ f2)%asgn))
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn (BotR (s_subst Γ s Γ2 f1 ₛ⊛ᵣ f2)) =
Whn (BotR (s_subst Γ s Γ3 (f1 ⊛ᵣ f2)%asgn))
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2
w2: whn Γ `+ B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
TenR ((w1 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) =
TenR (w1 `ᵥ⊛ f1 ⊛ᵣ f2) (w2 `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ2 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f1)
      ₛ⊛ᵣ r_shift2 f2)) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3), (s ₜ⊛ f1) ₛ⊛ᵣ f2 = s ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ2 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f1)
      ₛ⊛ᵣ r_shift2 f2)) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w1 `ᵥ⊛ f1 ⊛ᵣ f2
w2: whn Γ `- B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w2 `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ParL ((w1 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) =
ParL (w1 `ᵥ⊛ f1 ⊛ᵣ f2) (w2 `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OrR1 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = OrR1 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
OrR2 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = OrR2 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2)))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)
     (s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B)
        (a_shift1 f1) ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2)))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
AndL1 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = AndL1 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
AndL2 ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = AndL2 (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ShiftPR ((t `ₜ⊛ f1) ₜ⊛ᵣ f2) = ShiftPR (t `ₜ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
ShiftNL ((t `ₜ⊛ f1) ₜ⊛ᵣ f2) = ShiftNL (t `ₜ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
NegPR ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = NegPR (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A) (a_shift1 f1)
      ₛ⊛ᵣ r_shift1 f2)) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ᵣ f2))))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ᵣ f2 = w `ᵥ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
NegNL ((w `ᵥ⊛ f1) `ᵥ⊛ᵣ f2) = NegNL (w `ᵥ⊛ f1 ⊛ᵣ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t1 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t1 `ₜ⊛ f1 ⊛ᵣ f2
t2: term Γ `- A
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 ⊆ Γ3),
(t2 `ₜ⊛ f1) ₜ⊛ᵣ f2 = t2 `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
Cut p ((t1 `ₜ⊛ f1) ₜ⊛ᵣ f2) ((t2 `ₜ⊛ f1) ₜ⊛ᵣ f2) =
Cut p (t1 `ₜ⊛ f1 ⊛ᵣ f2) (t2 `ₜ⊛ f1 ⊛ᵣ f2)
  all: match goal with
       | |- Whn _ = Whn _ => do 2 f_equal
       | _ => f_equal
       end ; eauto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
(t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2)
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(t `ₜ⊛ f1) ₜ⊛ᵣ f2 = t `ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
(t `ₜ⊛ a_shift1 f1) ₜ⊛ᵣ r_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ⊛ᵣ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ 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) s (Γ2 ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 f1) ₛ⊛ᵣ r_shift2 f2 =
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Γ3 ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- 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) s (Γ2 ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 f1) ₛ⊛ᵣ r_shift2 f2 =
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Γ3 ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
  (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
  (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
  (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s1 ₜ⊛ f1) ₛ⊛ᵣ f2 = s1 ₜ⊛ f1 ⊛ᵣ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2) (f2 : Γ2 ⊆ Γ3),
(s2 ₜ⊛ f1) ₛ⊛ᵣ f2 = s2 ₜ⊛ f1 ⊛ᵣ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B) (a_shift1 f1)
ₛ⊛ᵣ r_shift1 f2 =
s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
  (a_shift1 (f1 ⊛ᵣ f2))
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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))
  all: first [ rewrite a_shift1_ren_r | rewrite a_shift2_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: 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 as [ [] | [] ]; cbn [ v_subst ].Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
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 neg
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 pos
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 neg
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 pos
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 neg
v: val Γ1 `+ p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2 now apply t_ren_sub.
  -Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty pos
v: val Γ1 `- p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2 now apply t_ren_sub.
  -Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 ⊆ Γ3
p: pre_ty neg
v: val Γ1 `- p
(v ᵥ⊛ f1) ᵥ⊛ᵣ f2 = v ᵥ⊛ f1 ⊛ᵣ f2 now apply w_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 : ty) (s : state (Γ ▶ₓ A †)),
s_sub_ren_P (Γ ▶ₓ A †) s -> t_sub_ren_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_sub_ren_P (Γ ▶ₓ `- A) `- A t ->
t_sub_ren_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_sub_ren_P (Γ ▶ₓ `+ A) `+ A t ->
t_sub_ren_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_sub_ren_P Γ A w -> t_sub_ren_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_sub_ren_P Γ A (Var h)
forall Γ : t_ctx, w_sub_ren_P Γ `- 0 ZerL
forall Γ : t_ctx, w_sub_ren_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_sub_ren_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_sub_ren_P Γ s -> w_sub_ren_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_sub_ren_P Γ s -> w_sub_ren_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_sub_ren_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_sub_ren_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_sub_ren_P Γ `+ B w2 ->
w_sub_ren_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_sub_ren_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_sub_ren_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_sub_ren_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_sub_ren_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_sub_ren_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_sub_ren_P Γ `- B w2 ->
w_sub_ren_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_sub_ren_P Γ `+ A w ->
w_sub_ren_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_sub_ren_P Γ `+ B w ->
w_sub_ren_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_sub_ren_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_sub_ren_P (Γ ▶ₓ `+ B) s2 ->
w_sub_ren_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_sub_ren_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_sub_ren_P (Γ ▶ₓ `- B) s2 ->
w_sub_ren_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_sub_ren_P Γ `- A w ->
w_sub_ren_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_sub_ren_P Γ `- B w ->
w_sub_ren_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_sub_ren_P Γ `+ A t ->
w_sub_ren_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_ren_P (Γ ▶ₓ `+ A) s ->
w_sub_ren_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_sub_ren_P (Γ ▶ₓ `- A) s ->
w_sub_ren_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_sub_ren_P Γ `- A t ->
w_sub_ren_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_sub_ren_P Γ `- A w ->
w_sub_ren_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_sub_ren_P (Γ ▶ₓ `- A) s ->
w_sub_ren_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_ren_P (Γ ▶ₓ `+ A) s ->
w_sub_ren_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_sub_ren_P Γ `+ A w ->
w_sub_ren_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_sub_ren_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_sub_ren_P Γ `- A t2 -> s_sub_ren_P Γ (Cut p t1 t2)
  all: unfold t_sub_ren_P, w_sub_ren_P, s_sub_ren_P.forall (Γ : t_ctx) (A : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
RecL t ₜ⊛ᵣ f1 `ₜ⊛ f2 = RecL t `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
RecR t ₜ⊛ᵣ f1 `ₜ⊛ f2 = RecR t `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Whn w ₜ⊛ᵣ f1 `ₜ⊛ f2 = Whn w `ₜ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A)
  (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2) (f2 : Γ2 =[ val ]> Γ3),
Var h `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = Var h `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
ZerL `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ZerL `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
TopR `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = TopR `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
OneR `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = OneR `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
OneL s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = OneL s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (s : state Γ),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
BotR s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = BotR s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
BotL `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = BotL `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall w2 : whn Γ `+ B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
TenR w1 w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = TenR w1 w2 `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
TenL s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = TenL s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
(forall (Γ2 Γ3 : t_ctx)
   (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
ParR s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ParR s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall w2 : whn Γ `- B,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
ParL w1 w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ParL w1 w2 `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
OrR1 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = OrR1 w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
OrR2 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = OrR2 w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2) ->
forall s2 : state (Γ ▶ₓ `+ B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
OrL s1 s2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = OrL s1 s2 `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2) ->
forall s2 : state (Γ ▶ₓ `- B),
(forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
AndR s1 s2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = AndR s1 s2 `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
AndL1 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = AndL1 w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
AndL2 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = AndL2 w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
ShiftPR t `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ShiftPR t `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
ShiftPL s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ShiftPL s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
ShiftNR s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ShiftNR s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
ShiftNL t `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = ShiftNL t `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
NegPR w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = NegPR w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty neg)
  (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),
NegPL s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = NegPL s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos)
  (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),
NegNR s `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = NegNR s `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
NegNL w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = NegNL w `ᵥ⊛ f1 ᵣ⊛ f2
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t1 ₜ⊛ᵣ f1 `ₜ⊛ f2 = t1 `ₜ⊛ f1 ᵣ⊛ f2) ->
forall t2 : term Γ `- A,
(forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
   (f2 : Γ2 =[ val ]> Γ3),
 t2 ₜ⊛ᵣ f1 `ₜ⊛ f2 = t2 `ₜ⊛ f1 ᵣ⊛ f2) ->
forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
Cut p t1 t2 ₛ⊛ᵣ f1 ₜ⊛ f2 = Cut p t1 t2 ₜ⊛ f1 ᵣ⊛ f2
  all: intros; cbn.Γ: t_ctx
A: 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
Mu
  (s_subst (Γ2 ▶ₓ A †) (s ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ A †)
     (a_shift1 f2)) =
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ3 ▶ₓ A †)
     (a_shift1 (f1 ᵣ⊛ f2)))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
RecL (t ₜ⊛ᵣ r_shift1 f1 `ₜ⊛ a_shift1 f2) =
RecL (t `ₜ⊛ a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
RecR (t ₜ⊛ᵣ r_shift1 f1 `ₜ⊛ a_shift1 f2) =
RecR (t `ₜ⊛ a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A: ty
w: whn Γ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ: t_ctx
A: ty
h: Γ ∋ A
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
f2 A (f1 A h) = f2 A (f1 A h)
Γ, Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn ZerL = Whn ZerL
Γ, Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn TopR = Whn TopR
Γ, Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn (OneL (s_subst Γ2 (s ₛ⊛ᵣ f1) Γ3 f2)) =
Whn (OneL (s_subst Γ s Γ3 (f1 ᵣ⊛ f2)%asgn))
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn (BotR (s_subst Γ2 (s ₛ⊛ᵣ f1) Γ3 f2)) =
Whn (BotR (s_subst Γ s Γ3 (f1 ᵣ⊛ f2)%asgn))
Γ, Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ᵣ⊛ f2
w2: whn Γ `+ B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
TenR (w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) (w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) =
TenR (w1 `ᵥ⊛ f1 ᵣ⊛ f2) (w2 `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (TenL
     (s_subst (Γ2 ▶ₓ `+ A ▶ₓ `+ B) (s ₛ⊛ᵣ r_shift2 f1)
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2))) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s ₛ⊛ᵣ f1 ₜ⊛ f2 = s ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (ParR
     (s_subst (Γ2 ▶ₓ `- A ▶ₓ `- B) (s ₛ⊛ᵣ r_shift2 f1)
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2))) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ᵣ⊛ f2
w2: whn Γ `- B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
ParL (w1 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) (w2 `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) =
ParL (w1 `ᵥ⊛ f1 ᵣ⊛ f2) (w2 `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
OrR1 (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = OrR1 (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
OrR2 (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = OrR2 (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (OrL
     (s_subst (Γ2 ▶ₓ `+ A) (s1 ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `+ A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `+ B) (s2 ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `+ B) (a_shift1 f2))) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ᵣ⊛ f2)))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (AndR
     (s_subst (Γ2 ▶ₓ `- A) (s1 ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `- A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `- B) (s2 ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `- B) (a_shift1 f2))) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ᵣ⊛ f2)))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
AndL1 (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = AndL1 (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
AndL2 (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = AndL2 (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
ShiftPR (t ₜ⊛ᵣ f1 `ₜ⊛ f2) = ShiftPR (t `ₜ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ2 ▶ₓ `+ A) (s ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ2 ▶ₓ `- A) (s ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
ShiftNL (t ₜ⊛ᵣ f1 `ₜ⊛ f2) = ShiftNL (t `ₜ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
NegPR (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = NegPR (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ2 ▶ₓ `- A) (s ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ2 ▶ₓ `+ A) (s ₛ⊛ᵣ r_shift1 f1)
        (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ᵣ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2 = w `ᵥ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
NegNL (w `ᵥ⊛ᵣ f1 `ᵥ⊛ f2) = NegNL (w `ᵥ⊛ f1 ᵣ⊛ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t1 ₜ⊛ᵣ f1 `ₜ⊛ f2 = t1 `ₜ⊛ f1 ᵣ⊛ f2
t2: term Γ `- A
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t2 ₜ⊛ᵣ f1 `ₜ⊛ f2 = t2 `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
Cut p (t1 ₜ⊛ᵣ f1 `ₜ⊛ f2) (t2 ₜ⊛ᵣ f1 `ₜ⊛ f2) =
Cut p (t1 `ₜ⊛ f1 ᵣ⊛ f2) (t2 `ₜ⊛ f1 ᵣ⊛ f2)
  all: match goal with
       | |- Whn _ = Whn _ => do 2 f_equal
       | _ => f_equal
       end ; eauto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
t ₜ⊛ᵣ r_shift1 f1 `ₜ⊛ a_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
t ₜ⊛ᵣ f1 `ₜ⊛ f2 = t `ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
t ₜ⊛ᵣ r_shift1 f1 `ₜ⊛ a_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ᵣ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ 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) (s ₛ⊛ᵣ r_shift2 f1)
  (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2) =
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Γ3 ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- 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) (s ₛ⊛ᵣ r_shift2 f1)
  (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2) =
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Γ3 ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `+ A) (s1 ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ `+ A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
  (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `+ B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `+ B) (s2 ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ `+ B)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
  (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `- A) (s1 ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ `- A)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
  (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- A) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s1 ₛ⊛ᵣ f1 ₜ⊛ f2 = s1 ₜ⊛ f1 ᵣ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx) (f1 : (Γ ▶ₓ `- B) ⊆ Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
s2 ₛ⊛ᵣ f1 ₜ⊛ f2 = s2 ₜ⊛ f1 ᵣ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `- B) (s2 ₛ⊛ᵣ r_shift1 f1) (Γ3 ▶ₓ `- B)
  (a_shift1 f2) =
s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
  (a_shift1 (f1 ᵣ⊛ f2))
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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))
  all: first [ rewrite a_shift1_ren_l | rewrite a_shift2_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: 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 as [ [] | [] ].Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty pos
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 neg
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 pos
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 neg
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 pos
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 neg
v: val Γ1 `+ p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2 now apply t_sub_ren.
  -Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty pos
v: val Γ1 `- p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2 now apply t_sub_ren.
  -Γ1, Γ2: ctx ty
Γ3: t_ctx
f1: Γ1 ⊆ Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty neg
v: val Γ1 `- p
v ᵥ⊛ᵣ f1 ᵥ⊛ f2 = v ᵥ⊛ f1 ᵣ⊛ f2 now apply w_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
  destruct A as [ [] | [] ]; auto.
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: Ctx.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: Ctx.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_shift2_comp {Γ1 Γ2 Γ3 A B} (f1 : Γ1 =[val]> Γ2) (f2 : Γ2 =[val]> Γ3)
  : @a_shift2 _ _ A B (f1 ⊛ f2) ≡ₐ a_shift2 f1 ⊛ a_shift2 f2 .Γ1, Γ2, Γ3: t_ctx
A, B: ty
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
a_shift2 (f1 ⊛ f2) ≡ₐ a_shift2 f1 ⊛ a_shift2 f2
  intros ? v; do 2 (dependent elimination v; cbn; [ now rewrite v_sub_id_r | ]).Γ0: ctx ty
Γ2, Γ3: t_ctx
y0, y: ty
f1: Γ0 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
a: ty
v: Ctx.var a Γ0
v_shift2 a (v_subst Γ2 a (f1 a v) Γ3 f2) =
v_subst (Γ2 ▶ₓ y0 ▶ₓ y) a (v_shift2 a (f1 a v))
  (Γ3 ▶ₓ y0 ▶ₓ y) (a_shift2 f2)
  now unfold v_shift2; 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 : ty) (s : state (Γ ▶ₓ A †)),
s_sub_sub_P (Γ ▶ₓ A †) s -> t_sub_sub_P Γ A (Mu s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_sub_sub_P (Γ ▶ₓ `- A) `- A t ->
t_sub_sub_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_sub_sub_P (Γ ▶ₓ `+ A) `+ A t ->
t_sub_sub_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_sub_sub_P Γ A w -> t_sub_sub_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_sub_sub_P Γ A (Var h)
forall Γ : t_ctx, w_sub_sub_P Γ `- 0 ZerL
forall Γ : t_ctx, w_sub_sub_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_sub_sub_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_sub_sub_P Γ s -> w_sub_sub_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_sub_sub_P Γ s -> w_sub_sub_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_sub_sub_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_sub_sub_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_sub_sub_P Γ `+ B w2 ->
w_sub_sub_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_sub_sub_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_sub_sub_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_sub_sub_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_sub_sub_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_sub_sub_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_sub_sub_P Γ `- B w2 ->
w_sub_sub_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_sub_sub_P Γ `+ A w ->
w_sub_sub_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_sub_sub_P Γ `+ B w ->
w_sub_sub_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_sub_sub_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_sub_sub_P (Γ ▶ₓ `+ B) s2 ->
w_sub_sub_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_sub_sub_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_sub_sub_P (Γ ▶ₓ `- B) s2 ->
w_sub_sub_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_sub_sub_P Γ `- A w ->
w_sub_sub_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_sub_sub_P Γ `- B w ->
w_sub_sub_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_sub_sub_P Γ `+ A t ->
w_sub_sub_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_sub_P (Γ ▶ₓ `+ A) s ->
w_sub_sub_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_sub_sub_P (Γ ▶ₓ `- A) s ->
w_sub_sub_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_sub_sub_P Γ `- A t ->
w_sub_sub_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_sub_sub_P Γ `- A w ->
w_sub_sub_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_sub_sub_P (Γ ▶ₓ `- A) s ->
w_sub_sub_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_sub_P (Γ ▶ₓ `+ A) s ->
w_sub_sub_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_sub_sub_P Γ `+ A w ->
w_sub_sub_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_sub_sub_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_sub_sub_P Γ `- A t2 -> s_sub_sub_P Γ (Cut p t1 t2)
  all: unfold t_sub_sub_P, w_sub_sub_P, s_sub_sub_P; intros; cbn.Γ: t_ctx
A: 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
Mu
  (s_subst (Γ2 ▶ₓ A †)
     (s_subst (Γ ▶ₓ A †) s (Γ2 ▶ₓ A †) (a_shift1 f1))
     (Γ3 ▶ₓ A †) (a_shift1 f2)) =
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ3 ▶ₓ A †)
     (a_shift1 (f1 ⊛ f2)))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
RecL ((t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2) =
RecL (t `ₜ⊛ a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
RecR ((t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2) =
RecR (t `ₜ⊛ a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A: ty
w: whn Γ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
(w `ᵥ⊛ f1) `ₜ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ: t_ctx
A: ty
h: Γ ∋ A
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
v_subst Γ2 A (f1 A h) Γ3 f2 =
v_subst Γ2 A (f1 A h) Γ3 f2
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn ZerL = Whn ZerL
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn TopR = Whn TopR
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn (OneL (s_subst Γ2 (s_subst Γ s Γ2 f1) Γ3 f2)) =
Whn (OneL (s_subst Γ s Γ3 (f1 ⊛ f2)%asgn))
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn (BotR (s_subst Γ2 (s_subst Γ s Γ2 f1) Γ3 f2)) =
Whn (BotR (s_subst Γ s Γ3 (f1 ⊛ f2)%asgn))
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ⊛ f2
w2: whn Γ `+ B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
TenR ((w1 `ᵥ⊛ f1) `ᵥ⊛ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ f2) =
TenR (w1 `ᵥ⊛ f1 ⊛ f2) (w2 `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ 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
Whn
  (TenL
     (s_subst (Γ2 ▶ₓ `+ A ▶ₓ `+ B)
        (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
           (Γ2 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f1))
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2))) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- 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
Whn
  (ParR
     (s_subst (Γ2 ▶ₓ `- A ▶ₓ `- B)
        (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
           (Γ2 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f1))
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2))) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ⊛ f2
w2: whn Γ `- B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ParL ((w1 `ᵥ⊛ f1) `ᵥ⊛ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ f2) =
ParL (w1 `ᵥ⊛ f1 ⊛ f2) (w2 `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OrR1 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = OrR1 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OrR2 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = OrR2 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (OrL
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `+ B)
        (s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ B) (a_shift1 f2))) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2)))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (AndR
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `- B)
        (s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B)
           (a_shift1 f1)) (Γ3 ▶ₓ `- B) (a_shift1 f2))) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2)))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
AndL1 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = AndL1 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
AndL2 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = AndL2 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ShiftPR ((t `ₜ⊛ f1) `ₜ⊛ f2) = ShiftPR (t `ₜ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ShiftNL ((t `ₜ⊛ f1) `ₜ⊛ f2) = ShiftNL (t `ₜ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
NegPR ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = NegPR (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
NegNL ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = NegNL (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t1 `ₜ⊛ f1) `ₜ⊛ f2 = t1 `ₜ⊛ f1 ⊛ f2
t2: term Γ `- A
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t2 `ₜ⊛ f1) `ₜ⊛ f2 = t2 `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Cut p ((t1 `ₜ⊛ f1) `ₜ⊛ f2) ((t2 `ₜ⊛ f1) `ₜ⊛ f2) =
Cut p (t1 `ₜ⊛ f1 ⊛ f2) (t2 `ₜ⊛ f1 ⊛ f2)
  4: destruct A as [ [] | [] ]; cbn.Γ: t_ctx
A: 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
Mu
  (s_subst (Γ2 ▶ₓ A †)
     (s_subst (Γ ▶ₓ A †) s (Γ2 ▶ₓ A †) (a_shift1 f1))
     (Γ3 ▶ₓ A †) (a_shift1 f2)) =
Mu
  (s_subst (Γ ▶ₓ A †) s (Γ3 ▶ₓ A †)
     (a_shift1 (f1 ⊛ f2)))
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
RecL ((t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2) =
RecL (t `ₜ⊛ a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
RecR ((t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2) =
RecR (t `ₜ⊛ a_shift1 (f1 ⊛ f2))
Γ: t_ctx
p: pre_ty pos
w: whn Γ `+ p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = Whn (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
p: pre_ty neg
w: whn Γ `+ p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
(w `ᵥ⊛ f1) `ₜ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ: t_ctx
p: pre_ty pos
w: whn Γ `- p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
(w `ᵥ⊛ f1) `ₜ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ: t_ctx
p: pre_ty neg
w: whn Γ `- p
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = Whn (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A: ty
h: Γ ∋ A
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
v_subst Γ2 A (f1 A h) Γ3 f2 =
v_subst Γ2 A (f1 A h) Γ3 f2
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn ZerL = Whn ZerL
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn TopR = Whn TopR
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OneR = OneR
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn (OneL (s_subst Γ2 (s_subst Γ s Γ2 f1) Γ3 f2)) =
Whn (OneL (s_subst Γ s Γ3 (f1 ⊛ f2)%asgn))
Γ: t_ctx
s: state Γ
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s ₜ⊛ f1) ₜ⊛ f2 = s ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn (BotR (s_subst Γ2 (s_subst Γ s Γ2 f1) Γ3 f2)) =
Whn (BotR (s_subst Γ s Γ3 (f1 ⊛ f2)%asgn))
Γ, Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ⊛ f2
w2: whn Γ `+ B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
TenR ((w1 `ᵥ⊛ f1) `ᵥ⊛ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ f2) =
TenR (w1 `ᵥ⊛ f1 ⊛ f2) (w2 `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ 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
Whn
  (TenL
     (s_subst (Γ2 ▶ₓ `+ A ▶ₓ `+ B)
        (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
           (Γ2 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f1))
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2))) =
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- 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
Whn
  (ParR
     (s_subst (Γ2 ▶ₓ `- A ▶ₓ `- B)
        (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
           (Γ2 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f1))
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2))) =
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w1 `ᵥ⊛ f1) ᵥ⊛ f2 = w1 `ᵥ⊛ f1 ⊛ f2
w2: whn Γ `- B
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w2 `ᵥ⊛ f1) ᵥ⊛ f2 = w2 `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ParL ((w1 `ᵥ⊛ f1) `ᵥ⊛ f2) ((w2 `ᵥ⊛ f1) `ᵥ⊛ f2) =
ParL (w1 `ᵥ⊛ f1 ⊛ f2) (w2 `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OrR1 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = OrR1 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
OrR2 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = OrR2 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (OrL
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `+ B)
        (s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ B) (a_shift1 f2))) =
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2)))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Whn
  (AndR
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))
     (s_subst (Γ2 ▶ₓ `- B)
        (s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B)
           (a_shift1 f1)) (Γ3 ▶ₓ `- B) (a_shift1 f2))) =
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2)))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
AndL1 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = AndL1 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
AndL2 ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = AndL2 (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ShiftPR ((t `ₜ⊛ f1) `ₜ⊛ f2) = ShiftPR (t `ₜ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (ShiftPL
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (ShiftNR
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
ShiftNL ((t `ₜ⊛ f1) `ₜ⊛ f2) = ShiftNL (t `ₜ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
NegPR ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = NegPR (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
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
Whn
  (NegPL
     (s_subst (Γ2 ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) s (Γ2 ▶ₓ `- A)
           (a_shift1 f1)) (Γ3 ▶ₓ `- A) (a_shift1 f2))) =
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ3 ▶ₓ `- A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
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
Whn
  (NegNR
     (s_subst (Γ2 ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) s (Γ2 ▶ₓ `+ A)
           (a_shift1 f1)) (Γ3 ▶ₓ `+ A) (a_shift1 f2))) =
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ3 ▶ₓ `+ A)
        (a_shift1 (f1 ⊛ f2))))
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(w `ᵥ⊛ f1) ᵥ⊛ f2 = w `ᵥ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
NegNL ((w `ᵥ⊛ f1) `ᵥ⊛ f2) = NegNL (w `ᵥ⊛ f1 ⊛ f2)
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t1 `ₜ⊛ f1) `ₜ⊛ f2 = t1 `ₜ⊛ f1 ⊛ f2
t2: term Γ `- A
H2: forall (Γ2 Γ3 : t_ctx) (f1 : Γ =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t2 `ₜ⊛ f1) `ₜ⊛ f2 = t2 `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
Cut p ((t1 `ₜ⊛ f1) `ₜ⊛ f2) ((t2 `ₜ⊛ f1) `ₜ⊛ f2) =
Cut p (t1 `ₜ⊛ f1 ⊛ f2) (t2 `ₜ⊛ f1 ⊛ f2)
  all: match goal with
       | |- Whn _ = Whn _ => do 2 f_equal
       | _ => f_equal
       end ; eauto.Γ: t_ctx
A: 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 pos
t: term (Γ ▶ₓ `- A) `- A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
(t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ⊛ f2)
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(t `ₜ⊛ f1) `ₜ⊛ f2 = t `ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
(t `ₜ⊛ a_shift1 f1) `ₜ⊛ a_shift1 f2 =
t `ₜ⊛ a_shift1 (f1 ⊛ f2)
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ 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)
  (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Γ2 ▶ₓ `+ A ▶ₓ `+ B)
     (a_shift2 f1)) (Γ3 ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 f2) =
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Γ3 ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- 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)
  (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Γ2 ▶ₓ `- A ▶ₓ `- B)
     (a_shift2 f1)) (Γ3 ▶ₓ `- A ▶ₓ `- B) (a_shift2 f2) =
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Γ3 ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `+ A)
  (s_subst (Γ ▶ₓ `+ A) s1 (Γ2 ▶ₓ `+ A) (a_shift1 f1))
  (Γ3 ▶ₓ `+ A) (a_shift1 f2) =
s_subst (Γ ▶ₓ `+ A) s1 (Γ3 ▶ₓ `+ A)
  (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `+ B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `+ B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `+ B)
  (s_subst (Γ ▶ₓ `+ B) s2 (Γ2 ▶ₓ `+ B) (a_shift1 f1))
  (Γ3 ▶ₓ `+ B) (a_shift1 f2) =
s_subst (Γ ▶ₓ `+ B) s2 (Γ3 ▶ₓ `+ B)
  (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `- A)
  (s_subst (Γ ▶ₓ `- A) s1 (Γ2 ▶ₓ `- A) (a_shift1 f1))
  (Γ3 ▶ₓ `- A) (a_shift1 f2) =
s_subst (Γ ▶ₓ `- A) s1 (Γ3 ▶ₓ `- A)
  (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- A) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s1 ₜ⊛ f1) ₜ⊛ f2 = s1 ₜ⊛ f1 ⊛ f2
s2: state (Γ ▶ₓ `- B)
H2: forall (Γ2 Γ3 : t_ctx)
  (f1 : (Γ ▶ₓ `- B) =[ val ]> Γ2)
  (f2 : Γ2 =[ val ]> Γ3),
(s2 ₜ⊛ f1) ₜ⊛ f2 = s2 ₜ⊛ f1 ⊛ f2
Γ2, Γ3: t_ctx
f1: Γ =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
s_subst (Γ2 ▶ₓ `- B)
  (s_subst (Γ ▶ₓ `- B) s2 (Γ2 ▶ₓ `- B) (a_shift1 f1))
  (Γ3 ▶ₓ `- B) (a_shift1 f2) =
s_subst (Γ ▶ₓ `- B) s2 (Γ3 ▶ₓ `- B)
  (a_shift1 (f1 ⊛ f2))
Γ: t_ctx
A: pre_ty neg
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 pos
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 neg
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 pos
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))
  all: first [ rewrite a_shift1_comp | rewrite a_shift2_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: 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 as [ [] | [] ].Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty pos
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 neg
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 pos
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 neg
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 pos
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 neg
v: val Γ1 `+ p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2 now apply t_sub_sub.
  -Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty pos
v: val Γ1 `- p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2 now apply t_sub_sub.
  -Γ1, Γ2, Γ3: t_ctx
f1: Γ1 =[ val ]> Γ2
f2: Γ2 =[ val ]> Γ3
p: pre_ty neg
v: val Γ1 `- p
(v ᵥ⊛ f1) ᵥ⊛ f2 = v ᵥ⊛ f1 ⊛ f2 now apply w_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 : 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 pos)
  (t : term (Γ ▶ₓ `- A) `- A),
t_sub_id_l_P (Γ ▶ₓ `- A) `- A t ->
t_sub_id_l_P Γ `- A (RecL t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (t : term (Γ ▶ₓ `+ A) `+ A),
t_sub_id_l_P (Γ ▶ₓ `+ A) `+ A t ->
t_sub_id_l_P Γ `+ A (RecR t)
forall (Γ : t_ctx) (A : ty) (w : whn Γ A),
w_sub_id_l_P Γ A w -> t_sub_id_l_P Γ A (Whn w)
forall (Γ : t_ctx) (A : ty) (h : Γ ∋ A),
w_sub_id_l_P Γ A (Var h)
forall Γ : t_ctx, w_sub_id_l_P Γ `- 0 ZerL
forall Γ : t_ctx, w_sub_id_l_P Γ `+ ⊤ TopR
forall Γ : t_ctx, w_sub_id_l_P Γ `+ 1 OneR
forall (Γ : t_ctx) (s : state Γ),
s_sub_id_l_P Γ s -> w_sub_id_l_P Γ `- 1 (OneL s)
forall (Γ : t_ctx) (s : state Γ),
s_sub_id_l_P Γ s -> w_sub_id_l_P Γ `+ ⊥ (BotR s)
forall Γ : t_ctx, w_sub_id_l_P Γ `- ⊥ BotL
forall (Γ : t_ctx) (A B : pre_ty pos)
  (w1 : whn Γ `+ A),
w_sub_id_l_P Γ `+ A w1 ->
forall w2 : whn Γ `+ B,
w_sub_id_l_P Γ `+ B w2 ->
w_sub_id_l_P Γ `+ (A ⊗ B) (TenR w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A ▶ₓ `+ B)),
s_sub_id_l_P (Γ ▶ₓ `+ A ▶ₓ `+ B) s ->
w_sub_id_l_P Γ `- (A ⊗ B) (TenL s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s : state (Γ ▶ₓ `- A ▶ₓ `- B)),
s_sub_id_l_P (Γ ▶ₓ `- A ▶ₓ `- B) s ->
w_sub_id_l_P Γ `+ (A ⅋ B) (ParR s)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (w1 : whn Γ `- A),
w_sub_id_l_P Γ `- A w1 ->
forall w2 : whn Γ `- B,
w_sub_id_l_P Γ `- B w2 ->
w_sub_id_l_P Γ `- (A ⅋ B) (ParL w1 w2)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ A),
w_sub_id_l_P Γ `+ A w ->
w_sub_id_l_P Γ `+ (A ⊕ B) (OrR1 w)
forall (Γ : t_ctx) (A B : pre_ty pos) (w : whn Γ `+ B),
w_sub_id_l_P Γ `+ B w ->
w_sub_id_l_P Γ `+ (A ⊕ B) (OrR2 w)
forall (Γ : t_ctx) (A B : pre_ty pos)
  (s1 : state (Γ ▶ₓ `+ A)),
s_sub_id_l_P (Γ ▶ₓ `+ A) s1 ->
forall s2 : state (Γ ▶ₓ `+ B),
s_sub_id_l_P (Γ ▶ₓ `+ B) s2 ->
w_sub_id_l_P Γ `- (A ⊕ B) (OrL s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg)
  (s1 : state (Γ ▶ₓ `- A)),
s_sub_id_l_P (Γ ▶ₓ `- A) s1 ->
forall s2 : state (Γ ▶ₓ `- B),
s_sub_id_l_P (Γ ▶ₓ `- B) s2 ->
w_sub_id_l_P Γ `+ (A & B) (AndR s1 s2)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- A),
w_sub_id_l_P Γ `- A w ->
w_sub_id_l_P Γ `- (A & B) (AndL1 w)
forall (Γ : t_ctx) (A B : pre_ty neg) (w : whn Γ `- B),
w_sub_id_l_P Γ `- B w ->
w_sub_id_l_P Γ `- (A & B) (AndL2 w)
forall (Γ : t_ctx) (A : pre_ty neg) (t : term Γ `+ A),
t_sub_id_l_P Γ `+ A t ->
w_sub_id_l_P Γ `+ (↓ A) (ShiftPR t)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_id_l_P (Γ ▶ₓ `+ A) s ->
w_sub_id_l_P Γ `- (↓ A) (ShiftPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `- A)),
s_sub_id_l_P (Γ ▶ₓ `- A) s ->
w_sub_id_l_P Γ `+ (↑ A) (ShiftNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (t : term Γ `- A),
t_sub_id_l_P Γ `- A t ->
w_sub_id_l_P Γ `- (↑ A) (ShiftNL t)
forall (Γ : t_ctx) (A : pre_ty neg) (w : whn Γ `- A),
w_sub_id_l_P Γ `- A w ->
w_sub_id_l_P Γ `+ (⊖ A) (NegPR w)
forall (Γ : t_ctx) (A : pre_ty neg)
  (s : state (Γ ▶ₓ `- A)),
s_sub_id_l_P (Γ ▶ₓ `- A) s ->
w_sub_id_l_P Γ `- (⊖ A) (NegPL s)
forall (Γ : t_ctx) (A : pre_ty pos)
  (s : state (Γ ▶ₓ `+ A)),
s_sub_id_l_P (Γ ▶ₓ `+ A) s ->
w_sub_id_l_P Γ `+ (¬ A) (NegNR s)
forall (Γ : t_ctx) (A : pre_ty pos) (w : whn Γ `+ A),
w_sub_id_l_P Γ `+ A w ->
w_sub_id_l_P Γ `- (¬ A) (NegNL w)
forall (Γ : t_ctx) (p : pol) (A : pre_ty p)
  (t1 : term Γ `+ A),
t_sub_id_l_P Γ `+ A t1 ->
forall t2 : term Γ `- A,
t_sub_id_l_P Γ `- A t2 -> s_sub_id_l_P Γ (Cut p t1 t2)
  all: unfold t_sub_id_l_P, w_sub_id_l_P, s_sub_id_l_P; intros; cbn.Γ: t_ctx
A: ty
s: state (Γ ▶ₓ A †)
H: s ₜ⊛ var = s
Mu (s_subst (Γ ▶ₓ A †) s (Γ ▶ₓ A †) (a_shift1 var)) =
Mu s
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: t `ₜ⊛ var = t
RecL (t `ₜ⊛ a_shift1 var) = RecL t
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: t `ₜ⊛ var = t
RecR (t `ₜ⊛ a_shift1 var) = RecR t
Γ: t_ctx
A: ty
w: whn Γ A
H: w `ᵥ⊛ var = w
w `ᵥ⊛ var = Whn w
Γ: t_ctx
A: ty
h: Γ ∋ A
var h = Var h
Γ: t_ctx
Whn ZerL = Whn ZerL
Γ: t_ctx
Whn TopR = Whn TopR
Γ: t_ctx
OneR = OneR
Γ: t_ctx
s: state Γ
H: s ₜ⊛ var = s
Whn (OneL (s_subst Γ s Γ var)) = Whn (OneL s)
Γ: t_ctx
s: state Γ
H: s ₜ⊛ var = s
Whn (BotR (s_subst Γ s Γ var)) = Whn (BotR s)
Γ: t_ctx
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: w1 `ᵥ⊛ var = w1
w2: whn Γ `+ B
H2: w2 `ᵥ⊛ var = w2
TenR (w1 `ᵥ⊛ var) (w2 `ᵥ⊛ var) = TenR w1 w2
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: s ₜ⊛ var = s
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 var))) =
Whn (TenL s)
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: s ₜ⊛ var = s
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ ▶ₓ `- A ▶ₓ `- B) (a_shift2 var))) =
Whn (ParR s)
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: w1 `ᵥ⊛ var = w1
w2: whn Γ `- B
H2: w2 `ᵥ⊛ var = w2
ParL (w1 `ᵥ⊛ var) (w2 `ᵥ⊛ var) = ParL w1 w2
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: w `ᵥ⊛ var = w
OrR1 (w `ᵥ⊛ var) = OrR1 w
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: w `ᵥ⊛ var = w
OrR2 (w `ᵥ⊛ var) = OrR2 w
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₜ⊛ var = s2
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ ▶ₓ `+ A)
        (a_shift1 var))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ ▶ₓ `+ B)
        (a_shift1 var))) = Whn (OrL s1 s2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₜ⊛ var = s2
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ ▶ₓ `- A)
        (a_shift1 var))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ ▶ₓ `- B)
        (a_shift1 var))) = Whn (AndR s1 s2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: w `ᵥ⊛ var = w
AndL1 (w `ᵥ⊛ var) = AndL1 w
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: w `ᵥ⊛ var = w
AndL2 (w `ᵥ⊛ var) = AndL2 w
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: t `ₜ⊛ var = t
ShiftPR (t `ₜ⊛ var) = ShiftPR t
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var))) =
Whn (ShiftPL s)
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var))) =
Whn (ShiftNR s)
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: t `ₜ⊛ var = t
ShiftNL (t `ₜ⊛ var) = ShiftNL t
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: w `ᵥ⊛ var = w
NegPR (w `ᵥ⊛ var) = NegPR w
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var))) =
Whn (NegPL s)
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var))) =
Whn (NegNR s)
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: w `ᵥ⊛ var = w
NegNL (w `ᵥ⊛ var) = NegNL w
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: t1 `ₜ⊛ var = t1
t2: term Γ `- A
H2: t2 `ₜ⊛ var = t2
Cut p (t1 `ₜ⊛ var) (t2 `ₜ⊛ var) = Cut p t1 t2
  4,5: destruct A as [ [] | [] ]; cbn.Γ: t_ctx
A: ty
s: state (Γ ▶ₓ A †)
H: s ₜ⊛ var = s
Mu (s_subst (Γ ▶ₓ A †) s (Γ ▶ₓ A †) (a_shift1 var)) =
Mu s
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: t `ₜ⊛ var = t
RecL (t `ₜ⊛ a_shift1 var) = RecL t
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: t `ₜ⊛ var = t
RecR (t `ₜ⊛ a_shift1 var) = RecR t
Γ: t_ctx
p: pre_ty pos
w: whn Γ `+ p
H: w `ᵥ⊛ var = w
Whn (w `ᵥ⊛ var) = Whn w
Γ: t_ctx
p: pre_ty neg
w: whn Γ `+ p
H: w `ᵥ⊛ var = w
w `ᵥ⊛ var = Whn w
Γ: t_ctx
p: pre_ty pos
w: whn Γ `- p
H: w `ᵥ⊛ var = w
w `ᵥ⊛ var = Whn w
Γ: t_ctx
p: pre_ty neg
w: whn Γ `- p
H: w `ᵥ⊛ var = w
Whn (w `ᵥ⊛ var) = Whn w
Γ: t_ctx
p: pre_ty pos
h: Γ ∋ `+ p
var h = Var h
Γ: t_ctx
p: pre_ty neg
h: Γ ∋ `+ p
var h = Whn (Var h)
Γ: t_ctx
p: pre_ty pos
h: Γ ∋ `- p
var h = Whn (Var h)
Γ: t_ctx
p: pre_ty neg
h: Γ ∋ `- p
var h = Var h
Γ: t_ctx
Whn ZerL = Whn ZerL
Γ: t_ctx
Whn TopR = Whn TopR
Γ: t_ctx
OneR = OneR
Γ: t_ctx
s: state Γ
H: s ₜ⊛ var = s
Whn (OneL (s_subst Γ s Γ var)) = Whn (OneL s)
Γ: t_ctx
s: state Γ
H: s ₜ⊛ var = s
Whn (BotR (s_subst Γ s Γ var)) = Whn (BotR s)
Γ: t_ctx
BotL = BotL
Γ: t_ctx
A, B: pre_ty pos
w1: whn Γ `+ A
H1: w1 `ᵥ⊛ var = w1
w2: whn Γ `+ B
H2: w2 `ᵥ⊛ var = w2
TenR (w1 `ᵥ⊛ var) (w2 `ᵥ⊛ var) = TenR w1 w2
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: s ₜ⊛ var = s
Whn
  (TenL
     (s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s
        (Γ ▶ₓ `+ A ▶ₓ `+ B) (a_shift2 var))) =
Whn (TenL s)
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: s ₜ⊛ var = s
Whn
  (ParR
     (s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s
        (Γ ▶ₓ `- A ▶ₓ `- B) (a_shift2 var))) =
Whn (ParR s)
Γ: t_ctx
A, B: pre_ty neg
w1: whn Γ `- A
H1: w1 `ᵥ⊛ var = w1
w2: whn Γ `- B
H2: w2 `ᵥ⊛ var = w2
ParL (w1 `ᵥ⊛ var) (w2 `ᵥ⊛ var) = ParL w1 w2
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ A
H: w `ᵥ⊛ var = w
OrR1 (w `ᵥ⊛ var) = OrR1 w
Γ: t_ctx
A, B: pre_ty pos
w: whn Γ `+ B
H: w `ᵥ⊛ var = w
OrR2 (w `ᵥ⊛ var) = OrR2 w
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₜ⊛ var = s2
Whn
  (OrL
     (s_subst (Γ ▶ₓ `+ A) s1 (Γ ▶ₓ `+ A)
        (a_shift1 var))
     (s_subst (Γ ▶ₓ `+ B) s2 (Γ ▶ₓ `+ B)
        (a_shift1 var))) = Whn (OrL s1 s2)
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₜ⊛ var = s2
Whn
  (AndR
     (s_subst (Γ ▶ₓ `- A) s1 (Γ ▶ₓ `- A)
        (a_shift1 var))
     (s_subst (Γ ▶ₓ `- B) s2 (Γ ▶ₓ `- B)
        (a_shift1 var))) = Whn (AndR s1 s2)
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- A
H: w `ᵥ⊛ var = w
AndL1 (w `ᵥ⊛ var) = AndL1 w
Γ: t_ctx
A, B: pre_ty neg
w: whn Γ `- B
H: w `ᵥ⊛ var = w
AndL2 (w `ᵥ⊛ var) = AndL2 w
Γ: t_ctx
A: pre_ty neg
t: term Γ `+ A
H: t `ₜ⊛ var = t
ShiftPR (t `ₜ⊛ var) = ShiftPR t
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
Whn
  (ShiftPL
     (s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var))) =
Whn (ShiftPL s)
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
Whn
  (ShiftNR
     (s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var))) =
Whn (ShiftNR s)
Γ: t_ctx
A: pre_ty pos
t: term Γ `- A
H: t `ₜ⊛ var = t
ShiftNL (t `ₜ⊛ var) = ShiftNL t
Γ: t_ctx
A: pre_ty neg
w: whn Γ `- A
H: w `ᵥ⊛ var = w
NegPR (w `ᵥ⊛ var) = NegPR w
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
Whn
  (NegPL
     (s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var))) =
Whn (NegPL s)
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
Whn
  (NegNR
     (s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var))) =
Whn (NegNR s)
Γ: t_ctx
A: pre_ty pos
w: whn Γ `+ A
H: w `ᵥ⊛ var = w
NegNL (w `ᵥ⊛ var) = NegNL w
Γ: t_ctx
p: pol
A: pre_ty p
t1: term Γ `+ A
H1: t1 `ₜ⊛ var = t1
t2: term Γ `- A
H2: t2 `ₜ⊛ var = t2
Cut p (t1 `ₜ⊛ var) (t2 `ₜ⊛ var) = Cut p t1 t2
  all: match goal with
       | |- Whn _ = Whn _ => do 2 f_equal
       | _ => f_equal
       end; eauto.Γ: t_ctx
A: ty
s: state (Γ ▶ₓ A †)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ A †) s (Γ ▶ₓ A †) (a_shift1 var) = s
Γ: t_ctx
A: pre_ty pos
t: term (Γ ▶ₓ `- A) `- A
H: t `ₜ⊛ var = t
t `ₜ⊛ a_shift1 var = t
Γ: t_ctx
A: pre_ty neg
t: term (Γ ▶ₓ `+ A) `+ A
H: t `ₜ⊛ var = t
t `ₜ⊛ a_shift1 var = t
Γ: t_ctx
A, B: pre_ty pos
s: state (Γ ▶ₓ `+ A ▶ₓ `+ B)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `+ A ▶ₓ `+ B) s (Γ ▶ₓ `+ A ▶ₓ `+ B)
  (a_shift2 var) = s
Γ: t_ctx
A, B: pre_ty neg
s: state (Γ ▶ₓ `- A ▶ₓ `- B)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `- A ▶ₓ `- B) s (Γ ▶ₓ `- A ▶ₓ `- B)
  (a_shift2 var) = s
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₜ⊛ var = s2
s_subst (Γ ▶ₓ `+ A) s1 (Γ ▶ₓ `+ A) (a_shift1 var) = s1
Γ: t_ctx
A, B: pre_ty pos
s1: state (Γ ▶ₓ `+ A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `+ B)
H2: s2 ₜ⊛ var = s2
s_subst (Γ ▶ₓ `+ B) s2 (Γ ▶ₓ `+ B) (a_shift1 var) = s2
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₜ⊛ var = s2
s_subst (Γ ▶ₓ `- A) s1 (Γ ▶ₓ `- A) (a_shift1 var) = s1
Γ: t_ctx
A, B: pre_ty neg
s1: state (Γ ▶ₓ `- A)
H1: s1 ₜ⊛ var = s1
s2: state (Γ ▶ₓ `- B)
H2: s2 ₜ⊛ var = s2
s_subst (Γ ▶ₓ `- B) s2 (Γ ▶ₓ `- B) (a_shift1 var) = s2
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var) = s
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var) = s
Γ: t_ctx
A: pre_ty neg
s: state (Γ ▶ₓ `- A)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `- A) s (Γ ▶ₓ `- A) (a_shift1 var) = s
Γ: t_ctx
A: pre_ty pos
s: state (Γ ▶ₓ `+ A)
H: s ₜ⊛ var = s
s_subst (Γ ▶ₓ `+ A) s (Γ ▶ₓ `+ A) (a_shift1 var) = s
  all: first [ rewrite a_shift1_id | rewrite a_shift2_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: 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 as [ [] | [] ].Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
v ᵥ⊛ var = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
v ᵥ⊛ var = v
Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
v ᵥ⊛ var = v
Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ var = v
  -Γ: t_ctx
p: pre_ty pos
v: val Γ `+ p
v ᵥ⊛ var = v now apply w_sub_id_l.
  -Γ: t_ctx
p: pre_ty neg
v: val Γ `+ p
v ᵥ⊛ var = v now apply t_sub_id_l.
  -Γ: t_ctx
p: pre_ty pos
v: val Γ `- p
v ᵥ⊛ var = v now apply t_sub_id_l.
  -Γ: t_ctx
p: pre_ty neg
v: val Γ `- p
v ᵥ⊛ var = v now apply w_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: Ctx.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: Ctx.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: Ctx.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: Ctx.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_sub2_sub {Γ Δ A B} (f : Γ =[val]> Δ) (s : state (Γ ▶ₓ A ▶ₓ B)) u v
  : (s ₜ⊛ a_shift2 f) ₜ⊛ ₂[ u ᵥ⊛ f , v ᵥ⊛ f ] = (s ₜ⊛ ₂[ u, v ]) ₜ⊛ f .Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B)
u: val Γ A
v: val Γ B
(s ₜ⊛ a_shift2 f) ₜ⊛ ₂[ u ᵥ⊛ f, v ᵥ⊛ f] =
(s ₜ⊛ ₂[ u, v]) ₜ⊛ f
  cbn; rewrite 2 s_sub_sub; apply s_sub_eq.Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B)
u: val Γ A
v: val Γ B
a_shift2 f ⊛ ₂[ v_subst Γ A u Δ f, v_subst Γ B v Δ f]
≡ₐ ₂[ u, v] ⊛ f
  intros ? v0; cbn.Γ, Δ: t_ctx
A, B: ty
f: Γ =[ val ]> Δ
s: state (Γ ▶ₓ A ▶ₓ B)
u: val Γ A
v: val Γ B
a: ty
v0: Γ ▶ₓ A ▶ₓ B ∋ a
v_subst (Δ ▶ₓ A ▶ₓ B) a (a_shift2 f a v0) Δ
  ₂[ v_subst Γ A u Δ f, v_subst Γ B v Δ f] =
v_subst Γ a (₂[ u, v] a v0) Δ f
  do 2 (dependent elimination v0; cbn; [ now rewrite v_sub_id_r | ]).Γ1: ctx ty
Δ: t_ctx
y0, y: ty
f: Γ1 =[ val ]> Δ
s: state (Γ1 ▶ₓ y0 ▶ₓ y)
u: val Γ1 y0
v: val Γ1 y
a: ty
v0: Ctx.var a Γ1
v_subst (Δ ▶ₓ y0 ▶ₓ y) a (v_shift2 a (f a v0)) Δ
  ₂[ v_subst Γ1 y0 u Δ f, v_subst Γ1 y v Δ f] =
v_subst Γ1 a (var v0) Δ f
  unfold v_shift2; rewrite v_sub_ren, v_sub_id_r, <- v_sub_id_l.Γ1: ctx ty
Δ: t_ctx
y0, y: ty
f: Γ1 =[ val ]> Δ
s: state (Γ1 ▶ₓ y0 ▶ₓ y)
u: val Γ1 y0
v: val Γ1 y
a: ty
v0: Ctx.var a Γ1
f a v0
ᵥ⊛ (r_pop ᵣ⊛ r_pop)
   ᵣ⊛ ₂[ v_subst Γ1 y0 u Δ f, v_subst Γ1 y v Δ 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 (p_dom m) Γ ==> eq) (p_app v m)
  intros u1 u2 H; destruct A as [ [] | []]; cbn; now rewrite (w_sub_eq u1 u2 H).
Qed.

Definition refold_id_aux_P (Γ : neg_ctx) p : pre_ty p -> Prop :=
  match p with
  | pos => fun A => forall (v : whn Γ `+A), p_of_w_0p _ v `ᵥ⊛ p_dom_of_w_0p _ v = v
  | neg => fun A => forall (v : whn Γ `-A), p_of_w_0n _ v `ᵥ⊛ p_dom_of_w_0n _ v = v
  end .

Lemma refold_id_aux {Γ p} A : refold_id_aux_P Γ p A .Γ: neg_ctx
p: pol
A: pre_ty p
refold_id_aux_P Γ p A
  induction A; intros v.Γ: neg_ctx
v: whn Γ `+ 0
p_of_w_0p 0 v `ᵥ⊛ p_dom_of_w_0p 0 v = v
Γ: neg_ctx
v: whn Γ `- ⊤
p_of_w_0n ⊤ v `ᵥ⊛ p_dom_of_w_0n ⊤ v = v
Γ: neg_ctx
v: whn Γ `+ 1
p_of_w_0p 1 v `ᵥ⊛ p_dom_of_w_0p 1 v = v
Γ: neg_ctx
v: whn Γ `- ⊥
p_of_w_0n ⊥ v `ᵥ⊛ p_dom_of_w_0n ⊥ v = v
Γ: neg_ctx
A1, A2: pre_ty pos
IHA1: refold_id_aux_P Γ pos A1
IHA2: refold_id_aux_P Γ pos A2
v: whn Γ `+ (A1 ⊗ A2)
p_of_w_0p (A1 ⊗ A2) v `ᵥ⊛ p_dom_of_w_0p (A1 ⊗ A2) v =
v
Γ: neg_ctx
A1, A2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A1
IHA2: refold_id_aux_P Γ neg A2
v: whn Γ `- (A1 ⅋ A2)
p_of_w_0n (A1 ⅋ A2) v `ᵥ⊛ p_dom_of_w_0n (A1 ⅋ A2) v =
v
Γ: neg_ctx
A1, A2: pre_ty pos
IHA1: refold_id_aux_P Γ pos A1
IHA2: refold_id_aux_P Γ pos A2
v: whn Γ `+ (A1 ⊕ A2)
p_of_w_0p (A1 ⊕ A2) v `ᵥ⊛ p_dom_of_w_0p (A1 ⊕ A2) v =
v
Γ: neg_ctx
A1, A2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A1
IHA2: refold_id_aux_P Γ neg A2
v: whn Γ `- (A1 & A2)
p_of_w_0n (A1 & A2) v `ᵥ⊛ p_dom_of_w_0n (A1 & A2) v =
v
Γ: neg_ctx
A: pre_ty neg
IHA: refold_id_aux_P Γ neg A
v: whn Γ `+ (↓ A)
p_of_w_0p (↓ A) v `ᵥ⊛ p_dom_of_w_0p (↓ A) v = v
Γ: neg_ctx
A: pre_ty pos
IHA: refold_id_aux_P Γ pos A
v: whn Γ `- (↑ A)
p_of_w_0n (↑ A) v `ᵥ⊛ p_dom_of_w_0n (↑ A) v = v
Γ: neg_ctx
A: pre_ty neg
IHA: refold_id_aux_P Γ neg A
v: whn Γ `+ (⊖ A)
p_of_w_0p ⊖ A v `ᵥ⊛ p_dom_of_w_0p ⊖ A v = v
Γ: neg_ctx
A: pre_ty pos
IHA: refold_id_aux_P Γ pos A
v: whn Γ `- (¬ A)
p_of_w_0n ¬ A v `ᵥ⊛ p_dom_of_w_0n ¬ A v = v
  -Γ: neg_ctx
v: whn Γ `+ 0
p_of_w_0p 0 v `ᵥ⊛ p_dom_of_w_0p 0 v = v dependent elimination v; destruct (s_prf c).
  -Γ: neg_ctx
v: whn Γ `- ⊤
p_of_w_0n ⊤ v `ᵥ⊛ p_dom_of_w_0n ⊤ v = v dependent elimination v; destruct (s_prf c).
  -Γ: neg_ctx
v: whn Γ `+ 1
p_of_w_0p 1 v `ᵥ⊛ p_dom_of_w_0p 1 v = v dependent elimination v; [ destruct (s_prf c) | ]; auto.
  -Γ: neg_ctx
v: whn Γ `- ⊥
p_of_w_0n ⊥ v `ᵥ⊛ p_dom_of_w_0n ⊥ v = v dependent elimination v; [ destruct (s_prf c) | ]; auto.
  -Γ: neg_ctx
A1, A2: pre_ty pos
IHA1: refold_id_aux_P Γ pos A1
IHA2: refold_id_aux_P Γ pos A2
v: whn Γ `+ (A1 ⊗ A2)
p_of_w_0p (A1 ⊗ A2) v `ᵥ⊛ p_dom_of_w_0p (A1 ⊗ A2) v =
v dependent elimination v; [ destruct (s_prf c) | ].Γ: neg_ctx
A0, B: pre_ty pos
IHA1: refold_id_aux_P Γ pos A0
IHA2: refold_id_aux_P Γ pos B
w: whn Γ `+ A0
w0: whn Γ `+ B
p_of_w_0p (A0 ⊗ B) (TenR w w0)
`ᵥ⊛ p_dom_of_w_0p (A0 ⊗ B) (TenR w w0) = 
TenR w w0
    cbn; f_equal; rewrite w_sub_ren.Γ: neg_ctx
A0, B: pre_ty pos
IHA1: refold_id_aux_P Γ pos A0
IHA2: refold_id_aux_P Γ pos B
w: whn Γ `+ A0
w0: whn Γ `+ B
p_of_w_0p A0 w
`ᵥ⊛ r_cover_l cover_cat
    ᵣ⊛ [p_dom_of_w_0p A0 w, p_dom_of_w_0p B w0] = w
Γ: neg_ctx
A0, B: pre_ty pos
IHA1: refold_id_aux_P Γ pos A0
IHA2: refold_id_aux_P Γ pos B
w: whn Γ `+ A0
w0: whn Γ `+ B
p_of_w_0p B w0
`ᵥ⊛ r_cover_r cover_cat
    ᵣ⊛ [p_dom_of_w_0p A0 w, p_dom_of_w_0p B w0] = w0
    rewrite <- IHA1; apply w_sub_eq; exact (a_cat_proj_l _ _).Γ: neg_ctx
A0, B: pre_ty pos
IHA1: refold_id_aux_P Γ pos A0
IHA2: refold_id_aux_P Γ pos B
w: whn Γ `+ A0
w0: whn Γ `+ B
p_of_w_0p B w0
`ᵥ⊛ r_cover_r cover_cat
    ᵣ⊛ [p_dom_of_w_0p A0 w, p_dom_of_w_0p B w0] = w0
    rewrite <- IHA2; apply w_sub_eq; exact (a_cat_proj_r _ _).
  -Γ: neg_ctx
A1, A2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A1
IHA2: refold_id_aux_P Γ neg A2
v: whn Γ `- (A1 ⅋ A2)
p_of_w_0n (A1 ⅋ A2) v `ᵥ⊛ p_dom_of_w_0n (A1 ⅋ A2) v =
v dependent elimination v; [ destruct (s_prf c) | ].Γ: neg_ctx
A5, B2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A5
IHA2: refold_id_aux_P Γ neg B2
w1: whn Γ `- A5
w2: whn Γ `- B2
p_of_w_0n (A5 ⅋ B2) (ParL w1 w2)
`ᵥ⊛ p_dom_of_w_0n (A5 ⅋ B2) (ParL w1 w2) = 
ParL w1 w2
    cbn; f_equal; rewrite w_sub_ren.Γ: neg_ctx
A5, B2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A5
IHA2: refold_id_aux_P Γ neg B2
w1: whn Γ `- A5
w2: whn Γ `- B2
p_of_w_0n A5 w1
`ᵥ⊛ r_cover_l cover_cat
    ᵣ⊛ [p_dom_of_w_0n A5 w1, p_dom_of_w_0n B2 w2] = w1
Γ: neg_ctx
A5, B2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A5
IHA2: refold_id_aux_P Γ neg B2
w1: whn Γ `- A5
w2: whn Γ `- B2
p_of_w_0n B2 w2
`ᵥ⊛ r_cover_r cover_cat
    ᵣ⊛ [p_dom_of_w_0n A5 w1, p_dom_of_w_0n B2 w2] = w2
    rewrite <- IHA1; apply w_sub_eq; exact (a_cat_proj_l _ _).Γ: neg_ctx
A5, B2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A5
IHA2: refold_id_aux_P Γ neg B2
w1: whn Γ `- A5
w2: whn Γ `- B2
p_of_w_0n B2 w2
`ᵥ⊛ r_cover_r cover_cat
    ᵣ⊛ [p_dom_of_w_0n A5 w1, p_dom_of_w_0n B2 w2] = w2
    rewrite <- IHA2; apply w_sub_eq; exact (a_cat_proj_r _ _).
  -Γ: neg_ctx
A1, A2: pre_ty pos
IHA1: refold_id_aux_P Γ pos A1
IHA2: refold_id_aux_P Γ pos A2
v: whn Γ `+ (A1 ⊕ A2)
p_of_w_0p (A1 ⊕ A2) v `ᵥ⊛ p_dom_of_w_0p (A1 ⊕ A2) v =
v dependent elimination v; [ destruct (s_prf c) | | ];
      cbn; f_equal; [ apply IHA1 | apply IHA2 ].
  -Γ: neg_ctx
A1, A2: pre_ty neg
IHA1: refold_id_aux_P Γ neg A1
IHA2: refold_id_aux_P Γ neg A2
v: whn Γ `- (A1 & A2)
p_of_w_0n (A1 & A2) v `ᵥ⊛ p_dom_of_w_0n (A1 & A2) v =
v dependent elimination v; [ destruct (s_prf c) | | ];
      cbn; f_equal; [ apply IHA1 | apply IHA2 ].
  -Γ: neg_ctx
A: pre_ty neg
IHA: refold_id_aux_P Γ neg A
v: whn Γ `+ (↓ A)
p_of_w_0p (↓ A) v `ᵥ⊛ p_dom_of_w_0p (↓ A) v = v dependent elimination v; [ destruct (s_prf c) | ]; cbn; f_equal.
  -Γ: neg_ctx
A: pre_ty pos
IHA: refold_id_aux_P Γ pos A
v: whn Γ `- (↑ A)
p_of_w_0n (↑ A) v `ᵥ⊛ p_dom_of_w_0n (↑ A) v = v dependent elimination v; [ destruct (s_prf c) | ]; cbn; f_equal.
  -Γ: neg_ctx
A: pre_ty neg
IHA: refold_id_aux_P Γ neg A
v: whn Γ `+ (⊖ A)
p_of_w_0p ⊖ A v `ᵥ⊛ p_dom_of_w_0p ⊖ A v = v dependent elimination v; [ destruct (s_prf c) | ].Γ: neg_ctx
A15: pre_ty neg
IHA: refold_id_aux_P Γ neg A15
w7: whn Γ `- A15
p_of_w_0p ⊖ A15 (NegPR w7)
`ᵥ⊛ p_dom_of_w_0p ⊖ A15 (NegPR w7) = 
NegPR w7
    cbn; f_equal; apply IHA.
  -Γ: neg_ctx
A: pre_ty pos
IHA: refold_id_aux_P Γ pos A
v: whn Γ `- (¬ A)
p_of_w_0n ¬ A v `ᵥ⊛ p_dom_of_w_0n ¬ A v = v dependent elimination v; [ destruct (s_prf c) | ].Γ: neg_ctx
A18: pre_ty pos
IHA: refold_id_aux_P Γ pos A18
w8: whn Γ `+ A18
p_of_w_0n ¬ A18 (NegNL w8)
`ᵥ⊛ p_dom_of_w_0n ¬ A18 (NegNL w8) = 
NegNL w8
    cbn; f_equal; apply IHA.
Qed.

Lemma refold_id {Γ : neg_ctx} A (v : val Γ A)
  : p_of_v A v `ᵥ⊛ p_dom_of_v A v = v.Γ: neg_ctx
A: ty
v: val Γ A
p_of_v A v `ᵥ⊛ p_dom_of_v A v = v
  destruct A as [ [] A | [] A ]; auto; exact (refold_id_aux A v).
Qed.

Equations p_of_w_eq_aux_p {Γ : neg_ctx} (A : pre_ty pos) (p : pat `+A) (e : p_dom p =[val]> Γ)
          : p_of_w_0p A (p `ᵥ⊛ e) = p
          by struct p :=
  p_of_w_eq_aux_p (1)     (POne)       e := eq_refl ;
  p_of_w_eq_aux_p (A ⊗ B) (PTen p1 p2) e := f_equal2 PTen
        (eq_trans (f_equal _ (w_sub_ren _ _ _ _)) (p_of_w_eq_aux_p A p1 _))
        (eq_trans (f_equal _ (w_sub_ren _ _ _ _)) (p_of_w_eq_aux_p B p2 _)) ;
  p_of_w_eq_aux_p (A ⊕ B) (POr1 p)     e := f_equal POr1 (p_of_w_eq_aux_p A p e) ;
  p_of_w_eq_aux_p (A ⊕ B) (POr2 p)     e := f_equal POr2 (p_of_w_eq_aux_p B p e) ;
  p_of_w_eq_aux_p (↓ A)   (PShiftP _)  e := eq_refl ;
  p_of_w_eq_aux_p (⊖ A)   (PNegP p)    e := f_equal PNegP (p_of_w_eq_aux_n A p e) ;

with p_of_w_eq_aux_n {Γ : neg_ctx} (A : pre_ty neg) (p : pat `-A) (e : p_dom p =[val]> Γ)
         : p_of_w_0n A (p `ᵥ⊛ e) = p
         by struct p :=
  p_of_w_eq_aux_n (⊥)     (PBot)       e := eq_refl ;
  p_of_w_eq_aux_n (A ⅋ B) (PPar p1 p2) e := f_equal2 PPar
        (eq_trans (f_equal _ (w_sub_ren _ _ _ _)) (p_of_w_eq_aux_n A p1 _))
        (eq_trans (f_equal _ (w_sub_ren _ _ _ _)) (p_of_w_eq_aux_n B p2 _)) ;
  p_of_w_eq_aux_n (A & B) (PAnd1 p)    e := f_equal PAnd1 (p_of_w_eq_aux_n A p e) ;
  p_of_w_eq_aux_n (A & B) (PAnd2 p)    e := f_equal PAnd2 (p_of_w_eq_aux_n B p e) ;
  p_of_w_eq_aux_n (↑ A)   (PShiftN _)  e := eq_refl ;
  p_of_w_eq_aux_n (¬ A)   (PNegN p)    e := f_equal PNegN (p_of_w_eq_aux_p A p e) .

Definition p_dom_of_w_eq_P (Γ : neg_ctx) p : pre_ty p -> Prop :=
  match p with
  | pos => fun A => forall (p : pat `+A) (e : p_dom p =[val]> Γ),
      rew [fun p => p_dom p =[ val ]> Γ] p_of_w_eq_aux_p A p e in p_dom_of_w_0p A (p `ᵥ⊛ e) ≡ₐ e
  | neg => fun A => forall (p : pat `-A) (e : p_dom p =[val]> Γ),
      rew [fun p => p_dom p =[ val ]> Γ] p_of_w_eq_aux_n A p e in p_dom_of_w_0n A (p `ᵥ⊛ e) ≡ₐ e
  end .

Lemma p_dom_of_v_eq {Γ p} A : p_dom_of_w_eq_P Γ p A .Γ: neg_ctx
p: pol
A: pre_ty p
p_dom_of_w_eq_P Γ p A
  induction A; intros p e; dependent elimination p; cbn - [ r_cat_l r_cat_r ].Γ: neg_ctx
e: p_dom POne =[ val ]> Γ
! ≡ₐ e
Γ: neg_ctx
e: p_dom PBot =[ val ]> Γ
! ≡ₐ e
Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
Γ: neg_ctx
A5, B1: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A5
IHA2: p_dom_of_w_eq_P Γ pos B1
p3: pat `+ A5
e: p_dom (POr1 p3) =[ val ]> Γ
rew [fun p : pat `+ (A5 ⊕ B1) => p_dom p =[ val ]> Γ]
    f_equal POr1 (p_of_w_eq_aux_p A5 p3 e) in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
A6, B2: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A6
IHA2: p_dom_of_w_eq_P Γ pos B2
p4: pat `+ B2
e: p_dom (POr2 p4) =[ val ]> Γ
rew [fun p : pat `+ (A6 ⊕ B2) => p_dom p =[ val ]> Γ]
    f_equal POr2 (p_of_w_eq_aux_p B2 p4 e) in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
A7, B3: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A7
IHA2: p_dom_of_w_eq_P Γ neg B3
p5: pat `- A7
e: p_dom (PAnd1 p5) =[ val ]> Γ
rew [fun p : pat `- (A7 & B3) => p_dom p =[ val ]> Γ]
    f_equal PAnd1 (p_of_w_eq_aux_n A7 p5 e) in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
A8, B4: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A8
IHA2: p_dom_of_w_eq_P Γ neg B4
p6: pat `- B4
e: p_dom (PAnd2 p6) =[ val ]> Γ
rew [fun p : pat `- (A8 & B4) => p_dom p =[ val ]> Γ]
    f_equal PAnd2 (p_of_w_eq_aux_n B4 p6 e) in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
A8: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A8
e: p_dom (PShiftP A8) =[ val ]> Γ
! ▶ₐ e `+ A8 top ≡ₐ e
Γ: neg_ctx
A9: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A9
e: p_dom (PShiftN A9) =[ val ]> Γ
! ▶ₐ e `- A9 top ≡ₐ e
Γ: neg_ctx
A10: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A10
p7: pat `- A10
e: p_dom (PNegP p7) =[ val ]> Γ
rew [fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ]
    f_equal PNegP (p_of_w_eq_aux_n A10 p7 e) in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e) ≡ₐ e
Γ: neg_ctx
A11: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A11
p8: pat `+ A11
e: p_dom (PNegN p8) =[ val ]> Γ
rew [fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ]
    f_equal PNegN (p_of_w_eq_aux_p A11 p8 e) in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e) ≡ₐ e
  -Γ: neg_ctx
e: p_dom POne =[ val ]> Γ
! ≡ₐ e intros ? h; repeat (dependent elimination h; auto).
  -Γ: neg_ctx
e: p_dom PBot =[ val ]> Γ
! ≡ₐ e intros ? h; repeat (dependent elimination h; auto).
  -Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e pose (H1 := w_sub_ren r_cat_l e `+A3 (w_of_p p)) .Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (H2 := w_sub_ren r_cat_r e `+B (w_of_p p0)) .Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (x1 := w_of_p p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e).Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (x2 := w_of_p p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e).Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
x2:= p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `+ B
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans
         (f_equal (p_of_w_0p A3)
            (w_sub_ren r_cat_l e `+ A3 p))
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (w_sub_ren r_cat_l e _ _) with H1.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
x2:= p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `+ B
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans (f_equal (p_of_w_0p A3) H1)
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0p B)
            (w_sub_ren r_cat_r e `+ B p0))
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (w_sub_ren r_cat_r e _ _) with H2.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `+ A3 p: p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
x2:= p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `+ B
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans (f_equal (p_of_w_0p A3) H1)
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0p B) H2)
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (_ `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e) with x1 in H1 |- *.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
H1:= w_sub_ren r_cat_l e `+ A3 p: x1 = p `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `+ B p0: p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
x2:= p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `+ B
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans (f_equal (p_of_w_0p A3) H1)
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0p B) H2)
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 x1,
p_dom_of_w_0p B (p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (_ `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e) with x2 in H2 |- *.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
x1:= p `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `+ A3
H1:= w_sub_ren r_cat_l e `+ A3 p: x1 = p `ᵥ⊛ r_cat_l ᵣ⊛ e
x2:= p0 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `+ B
H2:= w_sub_ren r_cat_r e `+ B p0: x2 = p0 `ᵥ⊛ r_cat_r ᵣ⊛ e
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans (f_equal (p_of_w_0p A3) H1)
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0p B) H2)
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 x1, p_dom_of_w_0p B x2] ≡ₐ e
    rewrite H1, H2; clear H1 H2 x1 x2; cbn - [ r_cat_l r_cat_r ].Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen
      (eq_trans eq_refl
         (p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e)))
      (eq_trans eq_refl
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    pose (H1 := p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e));
      change (p_of_w_eq_aux_p A3 _ _) with H1 in IHA1 |- *.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e): p_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e) = p
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen (eq_trans eq_refl H1)
      (eq_trans eq_refl
         (p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    pose (H2 := p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e));
      change (p_of_w_eq_aux_p B _ _) with H2 in IHA2 |- *.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e): p_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e) = p
H2:= p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e): p_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p0
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen (eq_trans eq_refl H1)
      (eq_trans eq_refl H2) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    transitivity ([ rew [fun p : pat `+A3 => p_dom p =[ val ]> Γ] H1
                     in p_dom_of_w_0p A3 (w_of_p p `ᵥ⊛ r_cat_l ᵣ⊛ e) ,
                    rew [fun p : pat `+B => p_dom p =[ val ]> Γ] H2
                     in p_dom_of_w_0p B (w_of_p p0 `ᵥ⊛ r_cat_r ᵣ⊛ e) ])%asgn.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e): p_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e) = p
H2:= p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e): p_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p0
rew [fun p : pat `+ (A3 ⊗ B) => p_dom p =[ val ]> Γ]
    f_equal2 PTen (eq_trans eq_refl H1)
      (eq_trans eq_refl H2) in
[p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)]
≡ₐ [rew [fun p : pat `+ A3 => p_dom p =[ val ]> Γ]
        H1 in p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
   rew [fun p : pat `+ B => p_dom p =[ val ]> Γ] H2 in
   p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)]
Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e): p_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e) = p
H2:= p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e): p_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p0
[rew [fun p : pat `+ A3 => p_dom p =[ val ]> Γ] H1 in
 p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
rew [fun p : pat `+ B => p_dom p =[ val ]> Γ] H2 in
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    now rewrite <- H1, <- H2, eq_refl_map2_distr.Γ: neg_ctx
A3, B: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A3
IHA2: p_dom_of_w_eq_P Γ pos B
p: pat `+ A3
p0: pat `+ B
e: p_dom (PTen p p0) =[ val ]> Γ
H1:= p_of_w_eq_aux_p A3 p (r_cat_l ᵣ⊛ e): p_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e) = p
H2:= p_of_w_eq_aux_p B p0 (r_cat_r ᵣ⊛ e): p_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p0
[rew [fun p : pat `+ A3 => p_dom p =[ val ]> Γ] H1 in
 p_dom_of_w_0p A3 (p `ᵥ⊛ r_cat_l ᵣ⊛ e),
rew [fun p : pat `+ B => p_dom p =[ val ]> Γ] H2 in
p_dom_of_w_0p B (p0 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    refine (a_cat_uniq _ _ _ _ _); [ apply IHA1 | apply IHA2 ] .
  -Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e pose (H1 := w_sub_ren r_cat_l e `-A4 (w_of_p p1)) .Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (H2 := w_sub_ren r_cat_r e `-B0 (w_of_p p2)) .Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (x1 := w_of_p p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e).Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    pose (x2 := w_of_p p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e).Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
x2:= p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `- B0
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans
         (f_equal (p_of_w_0n A4)
            (w_sub_ren r_cat_l e `- A4 p1))
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (w_sub_ren r_cat_l e _ _) with H1.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
x2:= p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `- B0
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans (f_equal (p_of_w_0n A4) H1)
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans
         (f_equal (p_of_w_0n B0)
            (w_sub_ren r_cat_r e `- B0 p2))
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (w_sub_ren r_cat_r e _ _) with H2.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= w_sub_ren r_cat_l e `- A4 p1: p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
x2:= p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `- B0
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans (f_equal (p_of_w_0n A4) H1)
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0n B0) H2)
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (_ `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e) with x1 in H1 |- *.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
H1:= w_sub_ren r_cat_l e `- A4 p1: x1 = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
H2:= w_sub_ren r_cat_r e `- B0 p2: p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
x2:= p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `- B0
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans (f_equal (p_of_w_0n A4) H1)
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0n B0) H2)
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 x1,
p_dom_of_w_0n B0 (p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e)] ≡ₐ e
    change (_ `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e) with x2 in H2 |- *.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
x1:= p1 `ᵥ⊛ᵣ r_cat_l `ᵥ⊛ e: val Γ `- A4
H1:= w_sub_ren r_cat_l e `- A4 p1: x1 = p1 `ᵥ⊛ r_cat_l ᵣ⊛ e
x2:= p2 `ᵥ⊛ᵣ r_cat_r `ᵥ⊛ e: val Γ `- B0
H2:= w_sub_ren r_cat_r e `- B0 p2: x2 = p2 `ᵥ⊛ r_cat_r ᵣ⊛ e
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans (f_equal (p_of_w_0n A4) H1)
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans (f_equal (p_of_w_0n B0) H2)
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 x1, p_dom_of_w_0n B0 x2] ≡ₐ e
    rewrite H1, H2; clear H1 H2 x1 x2; cbn - [ r_cat_l r_cat_r ].Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar
      (eq_trans eq_refl
         (p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e)))
      (eq_trans eq_refl
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    pose (H1 := p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e));
      change (p_of_w_eq_aux_n A4 _ _) with H1 in IHA1 |- *.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e): p_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) = p1
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar (eq_trans eq_refl H1)
      (eq_trans eq_refl
         (p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e))) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    pose (H2 := p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e));
      change (p_of_w_eq_aux_n B0 _ _) with H2 in IHA2 |- *.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e): p_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) = p1
H2:= p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e): p_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p2
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar (eq_trans eq_refl H1)
      (eq_trans eq_refl H2) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    transitivity ([ rew [fun p : pat `-A4 => p_dom p =[ val ]> Γ] H1
                     in p_dom_of_w_0n A4 (w_of_p p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) ,
                    rew [fun p : pat `-B0 => p_dom p =[ val ]> Γ] H2
                     in p_dom_of_w_0n B0 (w_of_p p2 `ᵥ⊛ r_cat_r ᵣ⊛ e) ])%asgn.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e): p_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) = p1
H2:= p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e): p_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p2
rew [fun p : pat `- (A4 ⅋ B0) => p_dom p =[ val ]> Γ]
    f_equal2 PPar (eq_trans eq_refl H1)
      (eq_trans eq_refl H2) in
[p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)]
≡ₐ [rew [fun p : pat `- A4 => p_dom p =[ val ]> Γ]
        H1 in p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
   rew [fun p : pat `- B0 => p_dom p =[ val ]> Γ]
       H2 in p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)]
Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e): p_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) = p1
H2:= p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e): p_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p2
[rew [fun p : pat `- A4 => p_dom p =[ val ]> Γ] H1 in
 p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
rew [fun p : pat `- B0 => p_dom p =[ val ]> Γ] H2 in
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    now rewrite <- H1, <- H2, eq_refl_map2_distr.Γ: neg_ctx
A4, B0: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A4
IHA2: p_dom_of_w_eq_P Γ neg B0
p1: pat `- A4
p2: pat `- B0
e: p_dom (PPar p1 p2) =[ val ]> Γ
H1:= p_of_w_eq_aux_n A4 p1 (r_cat_l ᵣ⊛ e): p_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e) = p1
H2:= p_of_w_eq_aux_n B0 p2 (r_cat_r ᵣ⊛ e): p_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e) = p2
[rew [fun p : pat `- A4 => p_dom p =[ val ]> Γ] H1 in
 p_dom_of_w_0n A4 (p1 `ᵥ⊛ r_cat_l ᵣ⊛ e),
rew [fun p : pat `- B0 => p_dom p =[ val ]> Γ] H2 in
p_dom_of_w_0n B0 (p2 `ᵥ⊛ r_cat_r ᵣ⊛ e)] ≡ₐ e
    refine (a_cat_uniq _ _ _ _ _); [ apply IHA1 | apply IHA2 ] .
  -Γ: neg_ctx
A5, B1: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A5
IHA2: p_dom_of_w_eq_P Γ pos B1
p3: pat `+ A5
e: p_dom (POr1 p3) =[ val ]> Γ
rew [fun p : pat `+ (A5 ⊕ B1) => p_dom p =[ val ]> Γ]
    f_equal POr1 (p_of_w_eq_aux_p A5 p3 e) in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A5, B1: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A5
IHA2: p_dom_of_w_eq_P Γ pos B1
p3: pat `+ A5
e: p_dom (POr1 p3) =[ val ]> Γ
xx:= rew [fun p : pat `+ (A5 ⊕ B1) =>
     p_dom p =[ val ]> Γ]
    f_equal POr1 (p_of_w_eq_aux_p A5 p3 e) in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e): (fun p : pat `+ (A5 ⊕ B1) => p_dom p =[ val ]> Γ)
  (POr1 p3)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A5, B1: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A5
IHA2: p_dom_of_w_eq_P Γ pos B1
p3: pat `+ A5
e: p_dom (POr1 p3) =[ val ]> Γ
xx': (fun p : pat `+ (A5 ⊕ B1) => p_dom p =[ val ]> Γ)
  (POr1 p3)
Heqxx': xx' =
rew [fun p : pat `+ (A5 ⊕ B1) =>
     p_dom p =[ val ]> Γ]
    f_equal POr1 (p_of_w_eq_aux_p A5 p3 e) in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ POr1 _ _))).Γ: neg_ctx
A5, B1: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A5
IHA2: p_dom_of_w_eq_P Γ pos B1
p3: pat `+ A5
e: p_dom (POr1 p3) =[ val ]> Γ
xx': (fun p : pat `+ (A5 ⊕ B1) => p_dom p =[ val ]> Γ)
  (POr1 p3)
Heqxx': xx' =
rew [fun p : pat `+ (A5 ⊕ B1) =>
     p_dom p =[ val ]> Γ]
    f_equal POr1 (p_of_w_eq_aux_p A5 p3 e) in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e)
rew [fun x : pat `+ A5 => p_dom (POr1 x) =[ val ]> Γ]
    p_of_w_eq_aux_p A5 p3 e in
p_dom_of_w_0p A5 (p3 `ᵥ⊛ e) ≡ₐ e
    apply IHA1.
  -Γ: neg_ctx
A6, B2: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A6
IHA2: p_dom_of_w_eq_P Γ pos B2
p4: pat `+ B2
e: p_dom (POr2 p4) =[ val ]> Γ
rew [fun p : pat `+ (A6 ⊕ B2) => p_dom p =[ val ]> Γ]
    f_equal POr2 (p_of_w_eq_aux_p B2 p4 e) in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A6, B2: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A6
IHA2: p_dom_of_w_eq_P Γ pos B2
p4: pat `+ B2
e: p_dom (POr2 p4) =[ val ]> Γ
xx:= rew [fun p : pat `+ (A6 ⊕ B2) =>
     p_dom p =[ val ]> Γ]
    f_equal POr2 (p_of_w_eq_aux_p B2 p4 e) in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e): (fun p : pat `+ (A6 ⊕ B2) => p_dom p =[ val ]> Γ)
  (POr2 p4)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A6, B2: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A6
IHA2: p_dom_of_w_eq_P Γ pos B2
p4: pat `+ B2
e: p_dom (POr2 p4) =[ val ]> Γ
xx': (fun p : pat `+ (A6 ⊕ B2) => p_dom p =[ val ]> Γ)
  (POr2 p4)
Heqxx': xx' =
rew [fun p : pat `+ (A6 ⊕ B2) =>
     p_dom p =[ val ]> Γ]
    f_equal POr2 (p_of_w_eq_aux_p B2 p4 e) in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ POr2 _ _))).Γ: neg_ctx
A6, B2: pre_ty pos
IHA1: p_dom_of_w_eq_P Γ pos A6
IHA2: p_dom_of_w_eq_P Γ pos B2
p4: pat `+ B2
e: p_dom (POr2 p4) =[ val ]> Γ
xx': (fun p : pat `+ (A6 ⊕ B2) => p_dom p =[ val ]> Γ)
  (POr2 p4)
Heqxx': xx' =
rew [fun p : pat `+ (A6 ⊕ B2) =>
     p_dom p =[ val ]> Γ]
    f_equal POr2 (p_of_w_eq_aux_p B2 p4 e) in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e)
rew [fun x : pat `+ B2 => p_dom (POr2 x) =[ val ]> Γ]
    p_of_w_eq_aux_p B2 p4 e in
p_dom_of_w_0p B2 (p4 `ᵥ⊛ e) ≡ₐ e
    apply IHA2.
  -Γ: neg_ctx
A7, B3: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A7
IHA2: p_dom_of_w_eq_P Γ neg B3
p5: pat `- A7
e: p_dom (PAnd1 p5) =[ val ]> Γ
rew [fun p : pat `- (A7 & B3) => p_dom p =[ val ]> Γ]
    f_equal PAnd1 (p_of_w_eq_aux_n A7 p5 e) in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A7, B3: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A7
IHA2: p_dom_of_w_eq_P Γ neg B3
p5: pat `- A7
e: p_dom (PAnd1 p5) =[ val ]> Γ
xx:= rew [fun p : pat `- (A7 & B3) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd1 (p_of_w_eq_aux_n A7 p5 e) in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e): (fun p : pat `- (A7 & B3) => p_dom p =[ val ]> Γ)
  (PAnd1 p5)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A7, B3: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A7
IHA2: p_dom_of_w_eq_P Γ neg B3
p5: pat `- A7
e: p_dom (PAnd1 p5) =[ val ]> Γ
xx': (fun p : pat `- (A7 & B3) => p_dom p =[ val ]> Γ)
  (PAnd1 p5)
Heqxx': xx' =
rew [fun p : pat `- (A7 & B3) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd1 (p_of_w_eq_aux_n A7 p5 e) in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PAnd1 _ _))).Γ: neg_ctx
A7, B3: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A7
IHA2: p_dom_of_w_eq_P Γ neg B3
p5: pat `- A7
e: p_dom (PAnd1 p5) =[ val ]> Γ
xx': (fun p : pat `- (A7 & B3) => p_dom p =[ val ]> Γ)
  (PAnd1 p5)
Heqxx': xx' =
rew [fun p : pat `- (A7 & B3) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd1 (p_of_w_eq_aux_n A7 p5 e) in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e)
rew [fun x : pat `- A7 => p_dom (PAnd1 x) =[ val ]> Γ]
    p_of_w_eq_aux_n A7 p5 e in
p_dom_of_w_0n A7 (p5 `ᵥ⊛ e) ≡ₐ e
    apply IHA1.
  -Γ: neg_ctx
A8, B4: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A8
IHA2: p_dom_of_w_eq_P Γ neg B4
p6: pat `- B4
e: p_dom (PAnd2 p6) =[ val ]> Γ
rew [fun p : pat `- (A8 & B4) => p_dom p =[ val ]> Γ]
    f_equal PAnd2 (p_of_w_eq_aux_n B4 p6 e) in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A8, B4: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A8
IHA2: p_dom_of_w_eq_P Γ neg B4
p6: pat `- B4
e: p_dom (PAnd2 p6) =[ val ]> Γ
xx:= rew [fun p : pat `- (A8 & B4) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd2 (p_of_w_eq_aux_n B4 p6 e) in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e): (fun p : pat `- (A8 & B4) => p_dom p =[ val ]> Γ)
  (PAnd2 p6)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A8, B4: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A8
IHA2: p_dom_of_w_eq_P Γ neg B4
p6: pat `- B4
e: p_dom (PAnd2 p6) =[ val ]> Γ
xx': (fun p : pat `- (A8 & B4) => p_dom p =[ val ]> Γ)
  (PAnd2 p6)
Heqxx': xx' =
rew [fun p : pat `- (A8 & B4) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd2 (p_of_w_eq_aux_n B4 p6 e) in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PAnd2 _ _))).Γ: neg_ctx
A8, B4: pre_ty neg
IHA1: p_dom_of_w_eq_P Γ neg A8
IHA2: p_dom_of_w_eq_P Γ neg B4
p6: pat `- B4
e: p_dom (PAnd2 p6) =[ val ]> Γ
xx': (fun p : pat `- (A8 & B4) => p_dom p =[ val ]> Γ)
  (PAnd2 p6)
Heqxx': xx' =
rew [fun p : pat `- (A8 & B4) =>
     p_dom p =[ val ]> Γ]
    f_equal PAnd2 (p_of_w_eq_aux_n B4 p6 e) in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e)
rew [fun x : pat `- B4 => p_dom (PAnd2 x) =[ val ]> Γ]
    p_of_w_eq_aux_n B4 p6 e in
p_dom_of_w_0n B4 (p6 `ᵥ⊛ e) ≡ₐ e
    apply IHA2.
  -Γ: neg_ctx
A8: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A8
e: p_dom (PShiftP A8) =[ val ]> Γ
! ▶ₐ e `+ A8 top ≡ₐ e intros ? v; repeat (dependent elimination v; auto).
  -Γ: neg_ctx
A9: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A9
e: p_dom (PShiftN A9) =[ val ]> Γ
! ▶ₐ e `- A9 top ≡ₐ e intros ? v; repeat (dependent elimination v; auto).
  -Γ: neg_ctx
A10: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A10
p7: pat `- A10
e: p_dom (PNegP p7) =[ val ]> Γ
rew [fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ]
    f_equal PNegP (p_of_w_eq_aux_n A10 p7 e) in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A10: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A10
p7: pat `- A10
e: p_dom (PNegP p7) =[ val ]> Γ
xx:= rew [fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ]
    f_equal PNegP (p_of_w_eq_aux_n A10 p7 e) in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e): (fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ)
  (PNegP p7)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A10: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A10
p7: pat `- A10
e: p_dom (PNegP p7) =[ val ]> Γ
xx': (fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ)
  (PNegP p7)
Heqxx': xx' =
rew [fun p : pat `+ (⊖ A10) =>
     p_dom p =[ val ]> Γ]
    f_equal PNegP (p_of_w_eq_aux_n A10 p7 e) in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PNegP _ _))).Γ: neg_ctx
A10: pre_ty neg
IHA: p_dom_of_w_eq_P Γ neg A10
p7: pat `- A10
e: p_dom (PNegP p7) =[ val ]> Γ
xx': (fun p : pat `+ (⊖ A10) => p_dom p =[ val ]> Γ)
  (PNegP p7)
Heqxx': xx' =
rew [fun p : pat `+ (⊖ A10) =>
     p_dom p =[ val ]> Γ]
    f_equal PNegP (p_of_w_eq_aux_n A10 p7 e) in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e)
rew [fun x : pat `- A10 => p_dom (PNegP x) =[ val ]> Γ]
    p_of_w_eq_aux_n A10 p7 e in
p_dom_of_w_0n A10 (p7 `ᵥ⊛ e) ≡ₐ e
    apply IHA.
  -Γ: neg_ctx
A11: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A11
p8: pat `+ A11
e: p_dom (PNegN p8) =[ val ]> Γ
rew [fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ]
    f_equal PNegN (p_of_w_eq_aux_p A11 p8 e) in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e) ≡ₐ e match goal with | |- ?s ≡ₐ e => pose (xx := s); change (_ ≡ₐ e) with (xx ≡ₐ e) end .Γ: neg_ctx
A11: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A11
p8: pat `+ A11
e: p_dom (PNegN p8) =[ val ]> Γ
xx:= rew [fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ]
    f_equal PNegN (p_of_w_eq_aux_p A11 p8 e) in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e): (fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ)
  (PNegN p8)
xx ≡ₐ e
    remember xx as xx'; unfold xx in Heqxx'; clear xx.Γ: neg_ctx
A11: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A11
p8: pat `+ A11
e: p_dom (PNegN p8) =[ val ]> Γ
xx': (fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ)
  (PNegN p8)
Heqxx': xx' =
rew [fun p : pat `- (¬ A11) =>
     p_dom p =[ val ]> Γ]
    f_equal PNegN (p_of_w_eq_aux_p A11 p8 e) in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e)
xx' ≡ₐ e
    rewrite (eq_trans Heqxx' (eq_sym (rew_map _ PNegN _ _))).Γ: neg_ctx
A11: pre_ty pos
IHA: p_dom_of_w_eq_P Γ pos A11
p8: pat `+ A11
e: p_dom (PNegN p8) =[ val ]> Γ
xx': (fun p : pat `- (¬ A11) => p_dom p =[ val ]> Γ)
  (PNegN p8)
Heqxx': xx' =
rew [fun p : pat `- (¬ A11) =>
     p_dom p =[ val ]> Γ]
    f_equal PNegN (p_of_w_eq_aux_p A11 p8 e) in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e)
rew [fun x : pat `+ A11 => p_dom (PNegN x) =[ val ]> Γ]
    p_of_w_eq_aux_p A11 p8 e in
p_dom_of_w_0p A11 (p8 `ᵥ⊛ e) ≡ₐ e
    apply IHA.
Qed.

(* coq unification drives me crazy!! *)
Definition upg_vp {Γ} {A : pre_ty pos} : whn Γ `+A  -> val Γ `+A := fun v => v.
Definition upg_kp {Γ} {A : pre_ty pos} : term Γ `-A -> val Γ `-A := fun v => v.
Definition upg_vn {Γ} {A : pre_ty neg} : term Γ `+A -> val Γ `+A := fun v => v.
Definition upg_kn {Γ} {A : pre_ty neg} : whn Γ `-A  -> val Γ `-A := fun v => v.
Definition dwn_vp {Γ} {A : pre_ty pos} : val Γ `+A -> whn Γ `+A  := fun v => v.
Definition dwn_kp {Γ} {A : pre_ty pos} : val Γ `-A -> term Γ `-A := fun v => v.
Definition dwn_vn {Γ} {A : pre_ty neg} : val Γ `+A -> term Γ `+A := fun v => v.
Definition dwn_kn {Γ} {A : pre_ty neg} : val Γ `-A -> whn Γ `-A  := fun v => v.

Lemma nf_eq_split_p {Γ : neg_ctx} {A : pre_ty pos} (i : Γ ∋ `-A) (p : pat `+A) γ
  : nf_eq (i ⋅ v_split_p (dwn_vp (p `ᵥ⊛ γ)))
          (i ⋅ (p : o_op obs_op `-A) ⦇ γ ⦈).Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
nf_eq (i ⋅ v_split_p (dwn_vp (p `ᵥ⊛ γ)))
  (i ⋅ (p : obs_op `- A) ⦇ γ ⦈)
  unfold v_split_p, dwn_vp; cbn.Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
nf_eq
  (i
   ⋅ p_of_w_0p A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0p A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose proof (p_dom_of_v_eq A p γ).Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
H: rew [fun p : pat `+ A => p_dom p =[ val ]> Γ]
    p_of_w_eq_aux_p A p γ in
p_dom_of_w_0p A (p `ᵥ⊛ γ) ≡ₐ γ
nf_eq
  (i
   ⋅ p_of_w_0p A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0p A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose (H' := p_of_w_eq_aux_p A p γ); fold H' in H.Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_p A p γ: p_of_w_0p A (p `ᵥ⊛ γ) = p
H: rew [fun p : pat `+ A => p_dom p =[ val ]> Γ]
    H' in p_dom_of_w_0p A (p `ᵥ⊛ γ) ≡ₐ γ
nf_eq
  (i
   ⋅ p_of_w_0p A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0p A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose (a := p_dom_of_w_0p A (w_of_p p `ᵥ⊛ γ)); fold a in H |- *.Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_p A p γ: p_of_w_0p A (p `ᵥ⊛ γ) = p
a:= p_dom_of_w_0p A (p `ᵥ⊛ γ): p_dom (p_of_w_0p A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat `+ A => p_dom p =[ val ]> Γ]
    H' in a ≡ₐ γ
nf_eq (i ⋅ p_of_w_0p A (p `ᵥ⊛ γ) ⦇ a ⦈) (i ⋅ p ⦇ γ ⦈)
  remember a as a'; clear a Heqa'.Γ: neg_ctx
A: pre_ty pos
i: Γ ∋ `- A
p: pat `+ A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_p A p γ: p_of_w_0p A (p `ᵥ⊛ γ) = p
a': p_dom (p_of_w_0p A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat `+ A => p_dom p =[ val ]> Γ]
    H' in a' ≡ₐ γ
nf_eq (i ⋅ p_of_w_0p A (p `ᵥ⊛ γ) ⦇ a' ⦈) (i ⋅ p ⦇ γ ⦈)
  revert a' H; rewrite H'; intros; now econstructor.
Qed.
Lemma nf_eq_split_n {Γ : neg_ctx} {A : pre_ty neg} (i : Γ ∋ `+A) (p : pat `-A) γ
  : nf_eq (i ⋅ v_split_n (dwn_kn (p `ᵥ⊛ γ)))
          (i ⋅ (p : o_op obs_op `+A) ⦇ γ ⦈).Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
nf_eq (i ⋅ v_split_n (dwn_kn (p `ᵥ⊛ γ)))
  (i ⋅ (p : obs_op `+ A) ⦇ γ ⦈)
  unfold v_split_n, dwn_kn; cbn.Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
nf_eq
  (i
   ⋅ p_of_w_0n A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0n A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose proof (p_dom_of_v_eq A p γ).Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
H: rew [fun p : pat `- A => p_dom p =[ val ]> Γ]
    p_of_w_eq_aux_n A p γ in
p_dom_of_w_0n A (p `ᵥ⊛ γ) ≡ₐ γ
nf_eq
  (i
   ⋅ p_of_w_0n A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0n A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose (H' := p_of_w_eq_aux_n A p γ); fold H' in H.Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_n A p γ: p_of_w_0n A (p `ᵥ⊛ γ) = p
H: rew [fun p : pat `- A => p_dom p =[ val ]> Γ]
    H' in p_dom_of_w_0n A (p `ᵥ⊛ γ) ≡ₐ γ
nf_eq
  (i
   ⋅ p_of_w_0n A (p `ᵥ⊛ γ) ⦇ p_dom_of_w_0n A (p `ᵥ⊛ γ)
     ⦈) (i ⋅ p ⦇ γ ⦈)
  pose (a := p_dom_of_w_0n A (w_of_p p `ᵥ⊛ γ)); fold a in H |- *.Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_n A p γ: p_of_w_0n A (p `ᵥ⊛ γ) = p
a:= p_dom_of_w_0n A (p `ᵥ⊛ γ): p_dom (p_of_w_0n A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat `- A => p_dom p =[ val ]> Γ]
    H' in a ≡ₐ γ
nf_eq (i ⋅ p_of_w_0n A (p `ᵥ⊛ γ) ⦇ a ⦈) (i ⋅ p ⦇ γ ⦈)
  remember a as a'; clear a Heqa'.Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
p: pat `- A
γ: p_dom p =[ val ]> Γ
H':= p_of_w_eq_aux_n A p γ: p_of_w_0n A (p `ᵥ⊛ γ) = p
a': p_dom (p_of_w_0n A (p `ᵥ⊛ γ)) =[ val ]> Γ
H: rew [fun p : pat `- A => p_dom p =[ val ]> Γ]
    H' in a' ≡ₐ γ
nf_eq (i ⋅ p_of_w_0n A (p `ᵥ⊛ γ) ⦇ a' ⦈) (i ⋅ p ⦇ γ ⦈)
  revert a' H; rewrite H'; intros; now econstructor.
Qed.

Finally we can return to saner pursuits.

OGS Instanciation

The notion of values and configurations we will pass to the generic OGS construction are our mu-mu-tilde values and states, but restricted to negative typing contexts. As such, while we have proven all the metatheory for arbitrary typing contexts, we still need a tiny bit of work to provide the laws in this special case. Once again, thanks to our tricky notion of subset context (Ctx/Subset.v), there is no need to cross a complex isomorphism (between contexts of negative types and contexts of types where all types are negative). We start by instanciating the substitution structures and their laws.

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.

Variable assumptions, that is, lemmata related to decidability of a value being a variable are easily proven inline.

#[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
p: pre_ty pos
c: Γ ∋ `+ p
decidable (is_var (Var c))
Γ: neg_ctx
decidable (is_var OneR)
Γ: neg_ctx
A0, B: pre_ty pos
w: whn Γ `+ A0
w0: whn Γ `+ B
decidable (is_var (TenR w w0))
Γ: neg_ctx
A4, B3: pre_ty pos
w3: whn Γ `+ A4
decidable (is_var (OrR1 w3))
Γ: neg_ctx
A5, B4: pre_ty pos
w4: whn Γ `+ B4
decidable (is_var (OrR2 w4))
Γ: neg_ctx
A10: pre_ty neg
t: term Γ `+ A10
decidable (is_var (ShiftPR t))
Γ: neg_ctx
A14: pre_ty neg
w7: whn Γ `- A14
decidable (is_var (NegPR w7))
Γ: neg_ctx
p: pre_ty neg
s: state (Γ ▶ₓ (`+ p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A1: pre_ty neg
t0: term (Γ ▶ₓ `+ A1) `+ A1
decidable (is_var (RecR t0))
Γ: neg_ctx
p: pre_ty neg
w: whn Γ `+ p
decidable (is_var (Whn w))
Γ: neg_ctx
p: pre_ty pos
s: state (Γ ▶ₓ (`- p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A0: pre_ty pos
t: term (Γ ▶ₓ `- A0) `- A0
decidable (is_var (RecL t))
Γ: neg_ctx
p: pre_ty pos
w: whn Γ `- p
decidable (is_var (Whn w))
Γ: neg_ctx
p: pre_ty neg
c: Γ ∋ `- p
decidable (is_var (Var c))
Γ: neg_ctx
decidable (is_var BotL)
Γ: neg_ctx
A3, B2: pre_ty neg
w1: whn Γ `- A3
w2: whn Γ `- B2
decidable (is_var (ParL w1 w2))
Γ: neg_ctx
A8, B7: pre_ty neg
w5: whn Γ `- A8
decidable (is_var (AndL1 w5))
Γ: neg_ctx
A9, B8: pre_ty neg
w6: whn Γ `- B8
decidable (is_var (AndL2 w6))
Γ: neg_ctx
A13: pre_ty pos
t0: term Γ `- A13
decidable (is_var (ShiftNL t0))
Γ: neg_ctx
A17: pre_ty pos
w8: whn Γ `+ A17
decidable (is_var (NegNL w8))
    10,13: dependent elimination w.Γ: neg_ctx
p: pre_ty pos
c: Γ ∋ `+ p
decidable (is_var (Var c))
Γ: neg_ctx
decidable (is_var OneR)
Γ: neg_ctx
A0, B: pre_ty pos
w: whn Γ `+ A0
w0: whn Γ `+ B
decidable (is_var (TenR w w0))
Γ: neg_ctx
A4, B3: pre_ty pos
w3: whn Γ `+ A4
decidable (is_var (OrR1 w3))
Γ: neg_ctx
A5, B4: pre_ty pos
w4: whn Γ `+ B4
decidable (is_var (OrR2 w4))
Γ: neg_ctx
A10: pre_ty neg
t: term Γ `+ A10
decidable (is_var (ShiftPR t))
Γ: neg_ctx
A14: pre_ty neg
w7: whn Γ `- A14
decidable (is_var (NegPR w7))
Γ: neg_ctx
p: pre_ty neg
s: state (Γ ▶ₓ (`+ p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A1: pre_ty neg
t0: term (Γ ▶ₓ `+ A1) `+ A1
decidable (is_var (RecR t0))
Γ: neg_ctx
p: pre_ty neg
c: Γ ∋ `+ p
decidable (is_var (Whn (Var c)))
Γ: neg_ctx
decidable (is_var (Whn TopR))
Γ: neg_ctx
s0: state Γ
decidable (is_var (Whn (BotR s0)))
Γ: neg_ctx
A2, B1: pre_ty neg
s2: state (Γ ▶ₓ `- A2 ▶ₓ `- B1)
decidable (is_var (Whn (ParR s2)))
Γ: neg_ctx
A7, B6: pre_ty neg
s5: state (Γ ▶ₓ `- A7)
s6: state (Γ ▶ₓ `- B6)
decidable (is_var (Whn (AndR s5 s6)))
Γ: neg_ctx
A12: pre_ty pos
s8: state (Γ ▶ₓ `- A12)
decidable (is_var (Whn (ShiftNR s8)))
Γ: neg_ctx
A16: pre_ty pos
s10: state (Γ ▶ₓ `+ A16)
decidable (is_var (Whn (NegNR s10)))
Γ: neg_ctx
p: pre_ty pos
c: Γ ∋ `- p
decidable (is_var (Whn (Var c)))
Γ: neg_ctx
decidable (is_var (Whn ZerL))
Γ: neg_ctx
s: state Γ
decidable (is_var (Whn (OneL s)))
Γ: neg_ctx
A1, B0: pre_ty pos
s1: state (Γ ▶ₓ `+ A1 ▶ₓ `+ B0)
decidable (is_var (Whn (TenL s1)))
Γ: neg_ctx
A6, B5: pre_ty pos
s3: state (Γ ▶ₓ `+ A6)
s4: state (Γ ▶ₓ `+ B5)
decidable (is_var (Whn (OrL s3 s4)))
Γ: neg_ctx
A11: pre_ty neg
s7: state (Γ ▶ₓ `+ A11)
decidable (is_var (Whn (ShiftPL s7)))
Γ: neg_ctx
A15: pre_ty neg
s9: state (Γ ▶ₓ `- A15)
decidable (is_var (Whn (NegPL s9)))
Γ: neg_ctx
p: pre_ty pos
s: state (Γ ▶ₓ (`- p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A0: pre_ty pos
t: term (Γ ▶ₓ `- A0) `- A0
decidable (is_var (RecL t))
Γ: neg_ctx
p: pre_ty neg
c: Γ ∋ `- p
decidable (is_var (Var c))
Γ: neg_ctx
decidable (is_var BotL)
Γ: neg_ctx
A3, B2: pre_ty neg
w1: whn Γ `- A3
w2: whn Γ `- B2
decidable (is_var (ParL w1 w2))
Γ: neg_ctx
A8, B7: pre_ty neg
w5: whn Γ `- A8
decidable (is_var (AndL1 w5))
Γ: neg_ctx
A9, B8: pre_ty neg
w6: whn Γ `- B8
decidable (is_var (AndL2 w6))
Γ: neg_ctx
A13: pre_ty pos
t0: term Γ `- A13
decidable (is_var (ShiftNL t0))
Γ: neg_ctx
A17: pre_ty pos
w8: whn Γ `+ A17
decidable (is_var (NegNL w8))
    all: try exact (Yes _ (Vvar _)).Γ: neg_ctx
decidable (is_var OneR)
Γ: neg_ctx
A0, B: pre_ty pos
w: whn Γ `+ A0
w0: whn Γ `+ B
decidable (is_var (TenR w w0))
Γ: neg_ctx
A4, B3: pre_ty pos
w3: whn Γ `+ A4
decidable (is_var (OrR1 w3))
Γ: neg_ctx
A5, B4: pre_ty pos
w4: whn Γ `+ B4
decidable (is_var (OrR2 w4))
Γ: neg_ctx
A10: pre_ty neg
t: term Γ `+ A10
decidable (is_var (ShiftPR t))
Γ: neg_ctx
A14: pre_ty neg
w7: whn Γ `- A14
decidable (is_var (NegPR w7))
Γ: neg_ctx
p: pre_ty neg
s: state (Γ ▶ₓ (`+ p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A1: pre_ty neg
t0: term (Γ ▶ₓ `+ A1) `+ A1
decidable (is_var (RecR t0))
Γ: neg_ctx
decidable (is_var (Whn TopR))
Γ: neg_ctx
s0: state Γ
decidable (is_var (Whn (BotR s0)))
Γ: neg_ctx
A2, B1: pre_ty neg
s2: state (Γ ▶ₓ `- A2 ▶ₓ `- B1)
decidable (is_var (Whn (ParR s2)))
Γ: neg_ctx
A7, B6: pre_ty neg
s5: state (Γ ▶ₓ `- A7)
s6: state (Γ ▶ₓ `- B6)
decidable (is_var (Whn (AndR s5 s6)))
Γ: neg_ctx
A12: pre_ty pos
s8: state (Γ ▶ₓ `- A12)
decidable (is_var (Whn (ShiftNR s8)))
Γ: neg_ctx
A16: pre_ty pos
s10: state (Γ ▶ₓ `+ A16)
decidable (is_var (Whn (NegNR s10)))
Γ: neg_ctx
decidable (is_var (Whn ZerL))
Γ: neg_ctx
s: state Γ
decidable (is_var (Whn (OneL s)))
Γ: neg_ctx
A1, B0: pre_ty pos
s1: state (Γ ▶ₓ `+ A1 ▶ₓ `+ B0)
decidable (is_var (Whn (TenL s1)))
Γ: neg_ctx
A6, B5: pre_ty pos
s3: state (Γ ▶ₓ `+ A6)
s4: state (Γ ▶ₓ `+ B5)
decidable (is_var (Whn (OrL s3 s4)))
Γ: neg_ctx
A11: pre_ty neg
s7: state (Γ ▶ₓ `+ A11)
decidable (is_var (Whn (ShiftPL s7)))
Γ: neg_ctx
A15: pre_ty neg
s9: state (Γ ▶ₓ `- A15)
decidable (is_var (Whn (NegPL s9)))
Γ: neg_ctx
p: pre_ty pos
s: state (Γ ▶ₓ (`- p) †)
decidable (is_var (Mu s))
Γ: neg_ctx
A0: pre_ty pos
t: term (Γ ▶ₓ `- A0) `- A0
decidable (is_var (RecL t))
Γ: neg_ctx
decidable (is_var BotL)
Γ: neg_ctx
A3, B2: pre_ty neg
w1: whn Γ `- A3
w2: whn Γ `- B2
decidable (is_var (ParL w1 w2))
Γ: neg_ctx
A8, B7: pre_ty neg
w5: whn Γ `- A8
decidable (is_var (AndL1 w5))
Γ: neg_ctx
A9, B8: pre_ty neg
w6: whn Γ `- B8
decidable (is_var (AndL2 w6))
Γ: neg_ctx
A13: pre_ty pos
t0: term Γ `- A13
decidable (is_var (ShiftNL t0))
Γ: neg_ctx
A17: pre_ty pos
w8: whn Γ `+ A17
decidable (is_var (NegNL w8))
    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
p: pre_ty pos
c: Γ1 ∋ `+ p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Var c) r)
is_var (Var c)
Γ2, Γ1: neg_ctx
r: Γ1 ⊆ Γ2
X: is_var (v_ren OneR r)
is_var OneR
Γ2, Γ1: neg_ctx
A, B: pre_ty pos
v1: whn Γ1 `+ A
v2: whn Γ1 `+ B
IHv1: forall (Γ3 : neg_ctx) (p : pre_ty pos)
  (v0 : whn Γ3 `+ p),
Γ1 ~= Γ3 ->
`+ A = `+ p ->
v1 ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
IHv2: forall (Γ3 : neg_ctx) (p : pre_ty pos)
  (v0 : whn Γ3 `+ p),
Γ1 ~= Γ3 ->
`+ B = `+ p ->
v2 ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (TenR v1 v2) r)
is_var (TenR v1 v2)
Γ2, Γ1: neg_ctx
A, B: pre_ty pos
v: whn Γ1 `+ A
IHv: forall (Γ3 : neg_ctx) (p : pre_ty pos)
  (v0 : whn Γ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 (OrR1 v) r)
is_var (OrR1 v)
Γ2, Γ1: neg_ctx
A, B: pre_ty pos
v: whn Γ1 `+ B
IHv: forall (Γ3 : neg_ctx) (p : pre_ty pos)
  (v0 : whn Γ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 (OrR2 v) r)
is_var (OrR2 v)
Γ2, Γ1: neg_ctx
A: pre_ty neg
t: term Γ1 `+ A
r: Γ1 ⊆ Γ2
X: is_var (v_ren (ShiftPR t) r)
is_var (ShiftPR t)
Γ2, Γ1: neg_ctx
A: pre_ty neg
v: whn Γ1 `- A
IHv: forall (Γ3 : neg_ctx) (p : pre_ty pos)
  (v0 : whn Γ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 (NegPR v) r)
is_var (NegPR v)
Γ2, Γ1: neg_ctx
p: pre_ty neg
s: state (Γ1 ▶ₓ (`+ p) †)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Mu s) r)
is_var (Mu s)
Γ2, Γ1: neg_ctx
p: pre_ty neg
v: term (Γ1 ▶ₓ `+ p) `+ p
IHv: forall (Γ3 : neg_ctx) (p0 : pre_ty neg)
  (v0 : term Γ3 `+ p0),
Γ1 ▶ₓ `+ p ~= Γ3 ->
`+ p = `+ p0 ->
v ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (RecR v) r)
is_var (RecR v)
Γ2, Γ1: neg_ctx
p: pre_ty neg
w: whn Γ1 `+ p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Whn w) r)
is_var (Whn w)
Γ2, Γ1: neg_ctx
p: pre_ty pos
s: state (Γ1 ▶ₓ (`- p) †)
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Mu s) r)
is_var (Mu s)
Γ2, Γ1: neg_ctx
p: pre_ty pos
v: term (Γ1 ▶ₓ `- p) `- p
IHv: forall (Γ3 : neg_ctx) (p0 : pre_ty pos)
  (v0 : term Γ3 `- p0),
Γ1 ▶ₓ `- p ~= Γ3 ->
`- p = `- p0 ->
v ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (RecL v) r)
is_var (RecL v)
Γ2, Γ1: neg_ctx
p: pre_ty pos
w: whn Γ1 `- p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Whn w) r)
is_var (Whn w)
Γ2, Γ1: neg_ctx
p: pre_ty neg
c: Γ1 ∋ `- p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Var c) r)
is_var (Var c)
Γ2, Γ1: neg_ctx
r: Γ1 ⊆ Γ2
X: is_var (v_ren BotL r)
is_var BotL
Γ2, Γ1: neg_ctx
A, B: pre_ty neg
v1: whn Γ1 `- A
v2: whn Γ1 `- B
IHv1: forall (Γ3 : neg_ctx) (p : pre_ty neg)
  (v0 : whn Γ3 `- p),
Γ1 ~= Γ3 ->
`- A = `- p ->
v1 ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
IHv2: forall (Γ3 : neg_ctx) (p : pre_ty neg)
  (v0 : whn Γ3 `- p),
Γ1 ~= Γ3 ->
`- B = `- p ->
v2 ~= v0 ->
forall r : Γ3 ⊆ Γ2,
is_var (v_ren v0 r) -> is_var v0
r: Γ1 ⊆ Γ2
X: is_var (v_ren (ParL v1 v2) r)
is_var (ParL v1 v2)
Γ2, Γ1: neg_ctx
A, B: pre_ty neg
v: whn Γ1 `- A
IHv: forall (Γ3 : neg_ctx) (p : pre_ty neg)
  (v0 : whn Γ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 (AndL1 v) r)
is_var (AndL1 v)
Γ2, Γ1: neg_ctx
A, B: pre_ty neg
v: whn Γ1 `- B
IHv: forall (Γ3 : neg_ctx) (p : pre_ty neg)
  (v0 : whn Γ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 (AndL2 v) r)
is_var (AndL2 v)
Γ2, Γ1: neg_ctx
A: pre_ty pos
t: term Γ1 `- A
r: Γ1 ⊆ Γ2
X: is_var (v_ren (ShiftNL t) r)
is_var (ShiftNL t)
Γ2, Γ1: neg_ctx
A: pre_ty pos
v: whn Γ1 `+ A
IHv: forall (Γ3 : neg_ctx) (p : pre_ty neg)
  (v0 : whn Γ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 (NegNL v) r)
is_var (NegNL v)
    all: try now dependent destruction X; exact (Vvar _).Γ2, Γ1: neg_ctx
p: pre_ty neg
w: whn Γ1 `+ p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Whn w) r)
is_var (Whn w)
Γ2, Γ1: neg_ctx
p: pre_ty pos
w: whn Γ1 `- p
r: Γ1 ⊆ Γ2
X: is_var (v_ren (Whn w) r)
is_var (Whn w)
    all: dependent induction w; dependent destruction X; exact (Vvar _).
Qed.

And we conclude the easy part by instanciating the relevant part of the language machine.

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

It now suffices to prove the remaining assumptions on the language machine: that evaluation respects substitution and that the 'bad-instanciation' relation has finite chains. For this we pull in some tooling for coinductive reasoning.

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).

Let's go.

#[global] Instance machine_law : machine_laws val_n state_n obs_op.machine_laws val_n state_n obs_op

First we have easy lemmata on observation application.

  esplit.forall (Γ : neg_ctx) (x : ty) (v : val Γ x)
  (o : obs_op x),
Proper (asgn_eq (dom o) Γ ==> eq) (oapp v o)
forall (Γ1 Γ2 : neg_ctx) (x : ty) (v : val Γ1 x)
  (o : obs_op 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 : Obs.nf obs_op val_n Γ =>
     Machine.eval (emb n ₜ⊛ a))
forall (Γ : neg_ctx) (u : Obs.nf obs_op val_n Γ),
Machine.eval (emb u) ≋ ret_delay u
well_founded head_inst_nostep
  -forall (Γ : neg_ctx) (x : ty) (v : val Γ x)
  (o : obs_op 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 : obs_op 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 pos
v: val Γ1 `+ p
o: obs_op `+ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut pos (Whn (v `ᵥ⊛ b)) ((o `ᵥ⊛ a) `ₜ⊛ b) =
Cut pos (Whn (v `ᵥ⊛ b)) (o `ᵥ⊛ a ⊛ b)
Γ1, Γ2: neg_ctx
p: pre_ty neg
v: val Γ1 `+ p
o: obs_op `+ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut neg (v `ₜ⊛ b) (Whn ((o `ᵥ⊛ a) `ᵥ⊛ b)) =
Cut neg (v `ₜ⊛ b) (Whn (o `ᵥ⊛ a ⊛ b))
Γ1, Γ2: neg_ctx
p: pre_ty pos
v: val Γ1 `- p
o: obs_op `- p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut pos (Whn ((o `ᵥ⊛ a) `ᵥ⊛ b)) (v `ₜ⊛ b) =
Cut pos (Whn (o `ᵥ⊛ a ⊛ b)) (v `ₜ⊛ b)
Γ1, Γ2: neg_ctx
p: pre_ty neg
v: val Γ1 `- p
o: obs_op `- p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut neg ((o `ᵥ⊛ a) `ₜ⊛ b) (Whn (v `ᵥ⊛ b)) =
Cut neg (o `ᵥ⊛ a ⊛ b) (Whn (v `ᵥ⊛ b))
    1,4: change (?a `ₜ⊛ ?b) with (a ᵥ⊛ b); now rewrite (w_sub_sub _ _ _ _).Γ1, Γ2: neg_ctx
p: pre_ty neg
v: val Γ1 `+ p
o: obs_op `+ p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut neg (v `ₜ⊛ b) (Whn ((o `ᵥ⊛ a) `ᵥ⊛ b)) =
Cut neg (v `ₜ⊛ b) (Whn (o `ᵥ⊛ a ⊛ b))
Γ1, Γ2: neg_ctx
p: pre_ty pos
v: val Γ1 `- p
o: obs_op `- p
a: dom o =[ val_n ]> Γ1
b: Γ1 =[ val_n ]> Γ2
Cut pos (Whn ((o `ᵥ⊛ a) `ᵥ⊛ b)) (v `ₜ⊛ b) =
Cut pos (Whn (o `ᵥ⊛ a ⊛ b)) (v `ₜ⊛ b)
    all: change (?a `ᵥ⊛ ?b) with (a ᵥ⊛ b) at 1; now rewrite (w_sub_sub _ _ _ _).

Next we prove the core argument of OGS soundness: evaluating a substitution is like evaluating the configuration, substituting the result and evaluating again. While tedious the proof is basically direct, going by induction on the structure of one-step evaluation.

  -forall (Γ Δ : neg_ctx) (c : state Γ)
  (a : Γ =[ val_n ]> Δ),
Machine.eval (c ₜ⊛ a)
≋ bind_delay' (Machine.eval c)
    (fun n : Obs.nf obs_op 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 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 : Obs.nf obs_op 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
A: pre_ty pos
c: state (Γ ▶ₓ (`+ A) †)
x: term Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Mu c) x) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Mu c) x) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (Mu c)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Whn v) (Mu c)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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 pos
v: whn Γ `+ A1
k: term (Γ ▶ₓ `- A1) `- A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (RecL k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Whn v) (RecL k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
i: Γ ∋ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (Whn (Var i))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut pos (Whn v) (Whn (Var i)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
c: state Γ
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn OneR) (Whn (OneL c))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut pos (Whn OneR) (Whn (OneL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A0, B: pre_ty pos
v1: whn Γ `+ A0
v2: whn Γ `+ B
c: state (Γ ▶ₓ `+ A0 ▶ₓ `+ B)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (TenR v1 v2)) (Whn (TenL c))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (TenR v1 v2)) (Whn (TenL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A4, B3: pre_ty pos
v: whn Γ `+ A4
c1: state (Γ ▶ₓ `+ A4)
c2: state (Γ ▶ₓ `+ B3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (OrR1 v)) (Whn (OrL c1 c2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (OrR1 v)) (Whn (OrL c1 c2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A5, B4: pre_ty pos
v: whn Γ `+ B4
c1: state (Γ ▶ₓ `+ A5)
c2: state (Γ ▶ₓ `+ B4)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (OrR2 v)) (Whn (OrL c1 c2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (OrR2 v)) (Whn (OrL c1 c2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A10: pre_ty neg
x: term Γ `+ A10
c: state (Γ ▶ₓ `+ A10)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (ShiftPR x)) (Whn (ShiftPL c)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (ShiftPR x)) (Whn (ShiftPL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A14: pre_ty neg
k: whn Γ `- A14
c: state (Γ ▶ₓ `- A14)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (NegPR k)) (Whn (NegPL c))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (NegPR k)) (Whn (NegPL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A: pre_ty neg
x: term Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg x (Mu c)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg x (Mu c)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A: pre_ty neg
c: state (Γ ▶ₓ (`+ A) †)
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Mu c) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg (Mu c) (Whn k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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 neg
t: term (Γ ▶ₓ `+ A2) `+ A2
k: whn Γ `- A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (RecR t) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg (RecR t) (Whn k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (Var i)) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut neg (Whn (Var i)) (Whn k))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
c: state Γ
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (BotR c)) (Whn BotL)) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut neg (Whn (BotR c)) (Whn BotL))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A4, B3: pre_ty neg
c: state (Γ ▶ₓ `- A4 ▶ₓ `- B3)
k1: whn Γ `- A4
k2: whn Γ `- B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (ParR c)) (Whn (ParL k1 k2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (ParR c)) (Whn (ParL k1 k2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A9, B8: pre_ty neg
c1: state (Γ ▶ₓ `- A9)
c2: state (Γ ▶ₓ `- B8)
k: whn Γ `- A9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (AndR c1 c2)) (Whn (AndL1 k)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (AndR c1 c2)) (Whn (AndL1 k)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A10, B9: pre_ty neg
c1: state (Γ ▶ₓ `- A10)
c2: state (Γ ▶ₓ `- B9)
k: whn Γ `- B9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (AndR c1 c2)) (Whn (AndL2 k)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (AndR c1 c2)) (Whn (AndL2 k)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A14: pre_ty pos
c: state (Γ ▶ₓ `- A14)
x: term Γ `- A14
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (ShiftNR c)) (Whn (ShiftNL x)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (ShiftNR c)) (Whn (ShiftNL x)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
Γ: neg_ctx
A18: pre_ty pos
c: state (Γ ▶ₓ `+ A18)
v: whn Γ `+ A18
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (NegNR c)) (Whn (NegNL v))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (NegNR c)) (Whn (NegNL v)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op val_n Γ =>
           eval
             (s_subst Γ
                (p_app (var (nf_var y)) (nf_obs y)
                   (nf_args y)) Δ a)) =<< k r)
  end
    +Γ: neg_ctx
A: pre_ty pos
c: state (Γ ▶ₓ (`+ A) †)
x: term Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Mu c) x) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Mu c) x) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A: pre_ty pos
c: state (Γ ▶ₓ (`+ A) †)
x: term Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) c (Δ ▶ₓ `- A)
           (a_shift1 a)) Δ ₁[ x `ₜ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `- A) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?t `ₜ⊛ ?a) with (upg_kp t ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A: pre_ty pos
c: state (Γ ▶ₓ (`+ A) †)
x: term Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_kp x]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `- A) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (Mu c)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Whn v) (Mu c)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A: pre_ty pos
v: whn Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) c (Δ ▶ₓ `+ A)
           (a_shift1 a)) Δ ₁[ v `ᵥ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `+ A) c Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?t `ᵥ⊛ ?a) with (upg_vp t ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_vp v]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `+ A) c Γ ₁[ v]))
     (fun y : Obs.nf obs_op 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 pos
v: whn Γ `+ A1
k: term (Γ ▶ₓ `- A1) `- A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (RecL k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut pos (Whn v) (RecL k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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 pos
v: whn Γ `+ A1
k: term (Γ ▶ₓ `- A1) `- A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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
     (Cut pos (Whn (v `ᵥ⊛ a))
        ((k `ₜ⊛ a_shift1 a)
         `ₜ⊛ ₁[ RecL (k `ₜ⊛ a_shift1 a)])))
  (bind_delay'
     (eval (Cut pos (Whn v) (k `ₜ⊛ ₁[ RecL k])))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (RecL (?t `ₜ⊛ a_shift1 ?a)) with (upg_kp (RecL t) ᵥ⊛ a); rewrite t_sub1_sub.Γ: neg_ctx
A1: pre_ty pos
v: whn Γ `+ A1
k: term (Γ ▶ₓ `- A1) `- A1
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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
     (Cut pos (Whn (v `ᵥ⊛ a))
        ((k `ₜ⊛ ₁[ upg_kp (RecL k)]) `ₜ⊛ a)))
  (bind_delay'
     (eval (Cut pos (Whn v) (k `ₜ⊛ ₁[ RecL k])))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
i: Γ ∋ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn v) (Whn (Var i))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut pos (Whn v) (Whn (Var i)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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 _ (Whn (v `ᵥ⊛ a)) (a `- A i)))
           (eval (Cut _
              (Whn ((w_of_p (p_of_w_0p A v) `ᵥ⊛ nf_args (s_var_upg i ⋅ v_split_p v)) `ᵥ⊛ a))
              (var (s_var_upg i) `ₜ⊛ a)))).Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
i: Γ ∋ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (v `ᵥ⊛ a)) (a `- A i)))
  (eval
     (Cut pos
        (Whn
           ((p_of_w_0p A v
             `ᵥ⊛ nf_args (s_var_upg i ⋅ v_split_p v))
            `ᵥ⊛ a)) (var (s_var_upg i) `ₜ⊛ a)))
      unfold nf_args, v_split_p, cut_r, fill_args.Γ: neg_ctx
A: pre_ty pos
v: whn Γ `+ A
i: Γ ∋ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (v `ᵥ⊛ a)) (a `- A i)))
  (eval
     (Cut pos
        (Whn
           ((p_of_w_0p A v `ᵥ⊛ p_dom_of_w_0p A v)
            `ᵥ⊛ a)) (var (s_var_upg i) `ₜ⊛ a)))
      now rewrite (refold_id_aux A v).
    +Γ: neg_ctx
c: state Γ
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn OneR) (Whn (OneL c))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut pos (Whn OneR) (Whn (OneL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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; apply CIH.
    +Γ: neg_ctx
A0, B: pre_ty pos
v1: whn Γ `+ A0
v2: whn Γ `+ B
c: state (Γ ▶ₓ `+ A0 ▶ₓ `+ B)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (TenR v1 v2)) (Whn (TenL c))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (TenR v1 v2)) (Whn (TenL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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, B: pre_ty pos
v1: whn Γ `+ A0
v2: whn Γ `+ B
c: state (Γ ▶ₓ `+ A0 ▶ₓ `+ B)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ▶ₓ `+ B)
        (s_subst (Γ ▶ₓ `+ A0 ▶ₓ `+ B) c
           (Δ ▶ₓ `+ A0 ▶ₓ `+ B) (a_shift2 a)) Δ
        ₂[ v1 `ᵥ⊛ a, v2 `ᵥ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ `+ A0 ▶ₓ `+ B) c Γ ₂[ v1, v2]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_vp v ᵥ⊛ a); rewrite s_sub2_sub.Γ: neg_ctx
A0, B: pre_ty pos
v1: whn Γ `+ A0
v2: whn Γ `+ B
c: state (Γ ▶ₓ `+ A0 ▶ₓ `+ B)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₂[ upg_vp v1, upg_vp v2]) ₜ⊛ a))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ `+ A0 ▶ₓ `+ B) c Γ ₂[ v1, v2]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A4, B3: pre_ty pos
v: whn Γ `+ A4
c1: state (Γ ▶ₓ `+ A4)
c2: state (Γ ▶ₓ `+ B3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (OrR1 v)) (Whn (OrL c1 c2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (OrR1 v)) (Whn (OrL c1 c2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A4, B3: pre_ty pos
v: whn Γ `+ A4
c1: state (Γ ▶ₓ `+ A4)
c2: state (Γ ▶ₓ `+ B3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ A4)
        (s_subst (Γ ▶ₓ `+ A4) c1 (Δ ▶ₓ `+ A4)
           (a_shift1 a)) Δ ₁[ v `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A4) c1 Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_vp v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A4, B3: pre_ty pos
v: whn Γ `+ A4
c1: state (Γ ▶ₓ `+ A4)
c2: state (Γ ▶ₓ `+ B3)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c1 ₜ⊛ ₁[ upg_vp v]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A4) c1 Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A5, B4: pre_ty pos
v: whn Γ `+ B4
c1: state (Γ ▶ₓ `+ A5)
c2: state (Γ ▶ₓ `+ B4)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (OrR2 v)) (Whn (OrL c1 c2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (OrR2 v)) (Whn (OrL c1 c2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A5, B4: pre_ty pos
v: whn Γ `+ B4
c1: state (Γ ▶ₓ `+ A5)
c2: state (Γ ▶ₓ `+ B4)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ B4)
        (s_subst (Γ ▶ₓ `+ B4) c2 (Δ ▶ₓ `+ B4)
           (a_shift1 a)) Δ ₁[ v `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ B4) c2 Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_vp v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A5, B4: pre_ty pos
v: whn Γ `+ B4
c1: state (Γ ▶ₓ `+ A5)
c2: state (Γ ▶ₓ `+ B4)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c2 ₜ⊛ ₁[ upg_vp v]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ B4) c2 Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A10: pre_ty neg
x: term Γ `+ A10
c: state (Γ ▶ₓ `+ A10)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (ShiftPR x)) (Whn (ShiftPL c)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (ShiftPR x)) (Whn (ShiftPL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A10: pre_ty neg
x: term Γ `+ A10
c: state (Γ ▶ₓ `+ A10)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ A10)
        (s_subst (Γ ▶ₓ `+ A10) c (Δ ▶ₓ `+ A10)
           (a_shift1 a)) Δ ₁[ x `ₜ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A10) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_vn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A10: pre_ty neg
x: term Γ `+ A10
c: state (Γ ▶ₓ `+ A10)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_vn x]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A10) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A14: pre_ty neg
k: whn Γ `- A14
c: state (Γ ▶ₓ `- A14)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 pos (Whn (NegPR k)) (Whn (NegPL c))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut pos (Whn (NegPR k)) (Whn (NegPL c)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A14: pre_ty neg
k: whn Γ `- A14
c: state (Γ ▶ₓ `- A14)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A14)
        (s_subst (Γ ▶ₓ `- A14) c (Δ ▶ₓ `- A14)
           (a_shift1 a)) Δ ₁[ k `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A14) c Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_kn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A14: pre_ty neg
k: whn Γ `- A14
c: state (Γ ▶ₓ `- A14)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_kn k]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A14) c Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A: pre_ty neg
x: term Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg x (Mu c)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg x (Mu c)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A: pre_ty neg
x: term Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ A)
        (s_subst (Γ ▶ₓ `+ A) c (Δ ▶ₓ `+ A)
           (a_shift1 a)) Δ ₁[ x `ₜ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `+ A) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_vn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A: pre_ty neg
x: term Γ `+ A
c: state (Γ ▶ₓ (`- A) †)
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_vn x]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `+ A) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A: pre_ty neg
c: state (Γ ▶ₓ (`+ A) †)
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Mu c) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg (Mu c) (Whn k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A: pre_ty neg
c: state (Γ ▶ₓ (`+ A) †)
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A)
        (s_subst (Γ ▶ₓ `- A) c (Δ ▶ₓ `- A)
           (a_shift1 a)) Δ ₁[ k `ᵥ⊛ a]))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `- A) c Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_kn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A: pre_ty neg
c: state (Γ ▶ₓ (`+ A) †)
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_kn k]) ₜ⊛ a))
  (bind_delay' (eval (s_subst (Γ ▶ₓ `- A) c Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A2: pre_ty neg
t: term (Γ ▶ₓ `+ A2) `+ A2
k: whn Γ `- A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (RecR t) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match eval_aux (Cut neg (RecR t) (Whn k)) with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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: pre_ty neg
t: term (Γ ▶ₓ `+ A2) `+ A2
k: whn Γ `- A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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
     (Cut neg
        ((t `ₜ⊛ a_shift1 a)
         `ₜ⊛ ₁[ RecR (t `ₜ⊛ a_shift1 a)])
        (Whn (k `ᵥ⊛ a))))
  (bind_delay'
     (eval (Cut neg (t `ₜ⊛ ₁[ RecR t]) (Whn k)))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (RecR (?t `ₜ⊛ a_shift1 ?a)) with (upg_vn (RecR t) ᵥ⊛ a); rewrite t_sub1_sub.Γ: neg_ctx
A2: pre_ty neg
t: term (Γ ▶ₓ `+ A2) `+ A2
k: whn Γ `- A2
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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
     (Cut neg ((t `ₜ⊛ ₁[ upg_vn (RecR t)]) `ₜ⊛ a)
        (Whn (k `ᵥ⊛ a))))
  (bind_delay'
     (eval (Cut neg (t `ₜ⊛ ₁[ RecR t]) (Whn k)))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (Var i)) (Whn k)) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut neg (Whn (Var i)) (Whn k))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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 _ (a `+ A i) (Whn (k `ᵥ⊛ a))))
           (eval (Cut _
              (var (s_var_upg i) `ₜ⊛ a)
              (Whn ((w_of_p (p_of_w_0n A k) `ᵥ⊛ nf_args (s_var_upg i ⋅ v_split_n k))
                      `ᵥ⊛ a))))).Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (a `+ A i) (Whn (k `ᵥ⊛ a))))
  (eval
     (Cut neg (var (s_var_upg i) `ₜ⊛ a)
        (Whn
           ((p_of_w_0n A k
             `ᵥ⊛ nf_args (s_var_upg i ⋅ v_split_n k))
            `ᵥ⊛ a))))
      unfold nf_args, v_split_n, cut_r, fill_args.Γ: neg_ctx
A: pre_ty neg
i: Γ ∋ `+ A
k: whn Γ `- A
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (a `+ A i) (Whn (k `ᵥ⊛ a))))
  (eval
     (Cut neg (var (s_var_upg i) `ₜ⊛ a)
        (Whn
           ((p_of_w_0n A k `ᵥ⊛ p_dom_of_w_0n A k)
            `ᵥ⊛ a))))
      now rewrite (refold_id_aux A k).
    +Γ: neg_ctx
c: state Γ
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (BotR c)) (Whn BotL)) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux (Cut neg (Whn (BotR c)) (Whn BotL))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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; apply CIH.
    +Γ: neg_ctx
A4, B3: pre_ty neg
c: state (Γ ▶ₓ `- A4 ▶ₓ `- B3)
k1: whn Γ `- A4
k2: whn Γ `- B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (ParR c)) (Whn (ParL k1 k2))) Δ
         a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (ParR c)) (Whn (ParL k1 k2)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A4, B3: pre_ty neg
c: state (Γ ▶ₓ `- A4 ▶ₓ `- B3)
k1: whn Γ `- A4
k2: whn Γ `- B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A4 ▶ₓ `- B3)
        (s_subst (Γ ▶ₓ `- A4 ▶ₓ `- B3) c
           (Δ ▶ₓ `- A4 ▶ₓ `- B3) (a_shift2 a)) Δ
        ₂[ k1 `ᵥ⊛ a, k2 `ᵥ⊛ a]))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ `- A4 ▶ₓ `- B3) c Γ ₂[ k1, k2]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_kn v ᵥ⊛ a); rewrite s_sub2_sub.Γ: neg_ctx
A4, B3: pre_ty neg
c: state (Γ ▶ₓ `- A4 ▶ₓ `- B3)
k1: whn Γ `- A4
k2: whn Γ `- B3
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₂[ upg_kn k1, upg_kn k2]) ₜ⊛ a))
  (bind_delay'
     (eval
        (s_subst (Γ ▶ₓ `- A4 ▶ₓ `- B3) c Γ ₂[ k1, k2]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A9, B8: pre_ty neg
c1: state (Γ ▶ₓ `- A9)
c2: state (Γ ▶ₓ `- B8)
k: whn Γ `- A9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (AndR c1 c2)) (Whn (AndL1 k)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (AndR c1 c2)) (Whn (AndL1 k)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A9, B8: pre_ty neg
c1: state (Γ ▶ₓ `- A9)
c2: state (Γ ▶ₓ `- B8)
k: whn Γ `- A9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A9)
        (s_subst (Γ ▶ₓ `- A9) c1 (Δ ▶ₓ `- A9)
           (a_shift1 a)) Δ ₁[ k `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A9) c1 Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_kn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A9, B8: pre_ty neg
c1: state (Γ ▶ₓ `- A9)
c2: state (Γ ▶ₓ `- B8)
k: whn Γ `- A9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c1 ₜ⊛ ₁[ upg_kn k]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A9) c1 Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A10, B9: pre_ty neg
c1: state (Γ ▶ₓ `- A10)
c2: state (Γ ▶ₓ `- B9)
k: whn Γ `- B9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (AndR c1 c2)) (Whn (AndL2 k)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (AndR c1 c2)) (Whn (AndL2 k)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A10, B9: pre_ty neg
c1: state (Γ ▶ₓ `- A10)
c2: state (Γ ▶ₓ `- B9)
k: whn Γ `- B9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- B9)
        (s_subst (Γ ▶ₓ `- B9) c2 (Δ ▶ₓ `- B9)
           (a_shift1 a)) Δ ₁[ k `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- B9) c2 Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_kn v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A10, B9: pre_ty neg
c1: state (Γ ▶ₓ `- A10)
c2: state (Γ ▶ₓ `- B9)
k: whn Γ `- B9
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c2 ₜ⊛ ₁[ upg_kn k]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- B9) c2 Γ ₁[ k]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A14: pre_ty pos
c: state (Γ ▶ₓ `- A14)
x: term Γ `- A14
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (ShiftNR c)) (Whn (ShiftNL x)))
         Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (ShiftNR c)) (Whn (ShiftNL x)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A14: pre_ty pos
c: state (Γ ▶ₓ `- A14)
x: term Γ `- A14
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `- A14)
        (s_subst (Γ ▶ₓ `- A14) c (Δ ▶ₓ `- A14)
           (a_shift1 a)) Δ ₁[ x `ₜ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A14) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ₜ⊛ ?a) with (upg_kp v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A14: pre_ty pos
c: state (Γ ▶ₓ `- A14)
x: term Γ `- A14
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_kp x]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `- A14) c Γ ₁[ x]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.
    +Γ: neg_ctx
A18: pre_ty pos
c: state (Γ ▶ₓ `+ A18)
v: whn Γ `+ A18
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 neg (Whn (NegNR c)) (Whn (NegNL v))) Δ a)
  with
  | inl x =>
      TauF
        (iter
           (fun pat : T1 =>
            let
            'T1_0 as x0 := pat
             return
               (state Δ ->
                itree ∅ₑ
                  ((fun _ : T1 => state Δ) +ᵢ
                   (fun _ : T1 => nf Δ)) x0) in
             fun c : state Δ => Ret' (eval_aux c))
           T1_0 x)
  | inr y => RetF y
  end
  match
    match
      eval_aux
        (Cut neg (Whn (NegNR c)) (Whn (NegNL v)))
    with
    | inl x =>
        TauF
          (iter
             (fun pat : T1 =>
              let
              'T1_0 as x0 := pat
               return
                 (state Γ ->
                  itree ∅ₑ
                    ((fun _ : T1 => state Γ) +ᵢ
                     (fun _ : T1 => 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 => 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
             (Obs.nf obs_op val_n Γ ->
              itree ∅ₑ
                (fun _ : T1 => Obs.nf obs_op val_n Δ)
                x) in
           fun y : Obs.nf obs_op 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
A18: pre_ty pos
c: state (Γ ▶ₓ `+ A18)
v: whn Γ `+ A18
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 (Δ ▶ₓ `+ A18)
        (s_subst (Γ ▶ₓ `+ A18) c (Δ ▶ₓ `+ A18)
           (a_shift1 a)) Δ ₁[ v `ᵥ⊛ a]))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A18) c Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      change (?v `ᵥ⊛ ?a) with (upg_vp v ᵥ⊛ a); rewrite s_sub1_sub.Γ: neg_ctx
A18: pre_ty pos
c: state (Γ ▶ₓ `+ A18)
v: whn Γ `+ A18
Δ: neg_ctx
R: relᵢ
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op val_n Δ))
  (itree ∅ₑ (fun _ : T1 => Obs.nf obs_op 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 : Obs.nf obs_op 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 ((c ₜ⊛ ₁[ upg_vp v]) ₜ⊛ a))
  (bind_delay'
     (eval (s_subst (Γ ▶ₓ `+ A18) c Γ ₁[ v]))
     (fun y : Obs.nf obs_op val_n Γ =>
      eval
        (s_subst Γ
           (p_app (var (nf_var y)) (nf_obs y)
              (nf_args y)) Δ a)))
      apply CIH.

Next we prove that evaluating a normal form is just returning this normal form. This goes by approximately induction on observations.

  -forall (Γ : neg_ctx) (u : Obs.nf obs_op 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: obs_op A
γ: dom o =[ val_n ]> Γ
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    cbn in o; funelim (w_of_p o); simpl_depind; inversion eqargs.A: pre_ty neg
Γ: neg_ctx
A0: ty
i: Γ ∋ A0
o: pat A0 †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ A; pr2 := PVarP A |} =
{| pr1 := A0 †; pr2 := o |}
H0: `+ A = A0 †
H1: `+ A,' PVarP A = A0 †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in Var Ctx.top `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A0: pre_ty pos
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- A0; pr2 := PVarN A0 |} =
{| pr1 := A †; pr2 := o |}
H0: `- A0 = A †
H1: `- A0,' PVarN A0 = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in Var Ctx.top `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ 1; pr2 := POne |} =
{| pr1 := A †; pr2 := o |}
H0: `+ 1 = A †
H1: `+ 1,' POne = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OneR `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- ⊥; pr2 := PBot |} =
{| pr1 := A †; pr2 := o |}
H0: `- ⊥ = A †
H1: `- ⊥,' PBot = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in BotL `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = 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 ⊗ B); pr2 := PTen p1 p2 |} =
{| pr1 := A †; pr2 := o |}
H2: `+ (A1 ⊗ B) = A †
H3: `+ (A1 ⊗ B),' PTen p1 p2 = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = 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 := `- (A2 ⅋ B0); pr2 := PPar p1 p2 |} =
{| pr1 := A †; pr2 := o |}
H2: `- (A2 ⅋ B0) = A †
H3: `- (A2 ⅋ B0),' PPar p1 p2 = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 := `+ (A3 ⊕ B1); pr2 := POr1 p |} =
{| pr1 := A †; pr2 := o |}
H1: `+ (A3 ⊕ B1) = A †
H2: `+ (A3 ⊕ B1),' POr1 p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 := `+ (A4 ⊕ B2); pr2 := POr2 p |} =
{| pr1 := A †; pr2 := o |}
H1: `+ (A4 ⊕ B2) = A †
H2: `+ (A4 ⊕ B2),' POr2 p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 & B3); pr2 := PAnd1 p |} =
{| pr1 := A †; pr2 := o |}
H1: `- (A5 & B3) = A †
H2: `- (A5 & B3),' PAnd1 p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 := `- (A6 & B4); pr2 := PAnd2 p |} =
{| pr1 := A †; pr2 := o |}
H1: `- (A6 & B4) = A †
H2: `- (A6 & B4),' PAnd2 p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (↓ A7); pr2 := PShiftP A7 |} =
{| pr1 := A †; pr2 := o |}
H0: `+ (↓ A7) = A †
H1: `+ (↓ A7),' PShiftP A7 = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftPR (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
A: ty
i: Γ ∋ A
o: pat A †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (↑ A8); pr2 := PShiftN A8 |} =
{| pr1 := A †; pr2 := o |}
H0: `- (↑ A8) = A †
H1: `- (↑ A8),' PShiftN A8 = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftNL (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 := `+ (⊖ A9); pr2 := PNegP p |} =
{| pr1 := A †; pr2 := o |}
H1: `+ (⊖ A9) = A †
H2: `+ (⊖ A9),' PNegP p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegPR p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = 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 := `- (¬ A10); pr2 := PNegN p |} =
{| pr1 := A †; pr2 := o |}
H1: `- (¬ A10) = A †
H2: `- (¬ A10),' PNegN p = A †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegNL p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    all: match goal with
         | H : _ = ?A† |- _ => destruct A; dependent destruction H
         end.p0: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- p0
o: pat (`- p0) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ p0; pr2 := PVarP p0 |} =
{| pr1 := (`- p0) †; pr2 := o |}
H1: `+ p0,' PVarP p0 = (`- p0) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in Var Ctx.top `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
p0: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ p0
o: pat (`+ p0) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- p0; pr2 := PVarN p0 |} =
{| pr1 := (`+ p0) †; pr2 := o |}
H1: `- p0,' PVarN p0 = (`+ p0) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in Var Ctx.top `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- 1
o: pat (`- 1) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ 1; pr2 := POne |} =
{| pr1 := (`- 1) †; pr2 := o |}
H1: `+ 1,' POne = (`- 1) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OneR `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ ⊥
o: pat (`+ ⊥) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- ⊥; pr2 := PBot |} =
{| pr1 := (`+ ⊥) †; pr2 := o |}
H1: `- ⊥,' PBot = (`+ ⊥) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in BotL `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A1 ⊗ B)
o: pat (`- (A1 ⊗ B)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A1 ⊗ B); pr2 := PTen p1 p2 |} =
{| pr1 := (`- (A1 ⊗ B)) †; pr2 := o |}
H3: `+ (A1 ⊗ B),' PTen p1 p2 = (`- (A1 ⊗ B)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A2 ⅋ B0)
o: pat (`+ (A2 ⅋ B0)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A2 ⅋ B0); pr2 := PPar p1 p2 |} =
{| pr1 := (`+ (A2 ⅋ B0)) †; pr2 := o |}
H3: `- (A2 ⅋ B0),' PPar p1 p2 = (`+ (A2 ⅋ B0)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A3 ⊕ B1)
o: pat (`- (A3 ⊕ B1)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A3 ⊕ B1); pr2 := POr1 p |} =
{| pr1 := (`- (A3 ⊕ B1)) †; pr2 := o |}
H2: `+ (A3 ⊕ B1),' POr1 p = (`- (A3 ⊕ B1)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A4 ⊕ B2)
o: pat (`- (A4 ⊕ B2)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A4 ⊕ B2); pr2 := POr2 p |} =
{| pr1 := (`- (A4 ⊕ B2)) †; pr2 := o |}
H2: `+ (A4 ⊕ B2),' POr2 p = (`- (A4 ⊕ B2)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A5 & B3)
o: pat (`+ (A5 & B3)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A5 & B3); pr2 := PAnd1 p |} =
{| pr1 := (`+ (A5 & B3)) †; pr2 := o |}
H2: `- (A5 & B3),' PAnd1 p = (`+ (A5 & B3)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A6 & B4)
o: pat (`+ (A6 & B4)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A6 & B4); pr2 := PAnd2 p |} =
{| pr1 := (`+ (A6 & B4)) †; pr2 := o |}
H2: `- (A6 & B4),' PAnd2 p = (`+ (A6 & B4)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- (↓ A7)
o: pat (`- (↓ A7)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (↓ A7); pr2 := PShiftP A7 |} =
{| pr1 := (`- (↓ A7)) †; pr2 := o |}
H1: `+ (↓ A7),' PShiftP A7 = (`- (↓ A7)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftPR (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ (↑ A8)
o: pat (`+ (↑ A8)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (↑ A8); pr2 := PShiftN A8 |} =
{| pr1 := (`+ (↑ A8)) †; pr2 := o |}
H1: `- (↑ A8),' PShiftN A8 = (`+ (↑ A8)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftNL (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (⊖ A9)
o: pat (`- (⊖ A9)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (⊖ A9); pr2 := PNegP p |} =
{| pr1 := (`- (⊖ A9)) †; pr2 := o |}
H2: `+ (⊖ A9),' PNegP p = (`- (⊖ A9)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegPR p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (¬ A10)
o: pat (`+ (¬ A10)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (¬ A10); pr2 := PNegN p |} =
{| pr1 := (`+ (¬ A10)) †; pr2 := o |}
H2: `- (¬ A10),' PNegN p = (`+ (¬ A10)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegNL p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    1-2: unfold c_var in i; destruct (s_prf i).Γ: neg_ctx
i: Γ ∋ `- 1
o: pat (`- 1) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ 1; pr2 := POne |} =
{| pr1 := (`- 1) †; pr2 := o |}
H1: `+ 1,' POne = (`- 1) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OneR `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ ⊥
o: pat (`+ ⊥) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- ⊥; pr2 := PBot |} =
{| pr1 := (`+ ⊥) †; pr2 := o |}
H1: `- ⊥,' PBot = (`+ ⊥) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in BotL `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A1 ⊗ B)
o: pat (`- (A1 ⊗ B)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A1 ⊗ B); pr2 := PTen p1 p2 |} =
{| pr1 := (`- (A1 ⊗ B)) †; pr2 := o |}
H3: `+ (A1 ⊗ B),' PTen p1 p2 = (`- (A1 ⊗ B)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A2 ⅋ B0)
o: pat (`+ (A2 ⅋ B0)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A2 ⅋ B0); pr2 := PPar p1 p2 |} =
{| pr1 := (`+ (A2 ⅋ B0)) †; pr2 := o |}
H3: `- (A2 ⅋ B0),' PPar p1 p2 = (`+ (A2 ⅋ B0)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in
      ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat)
        (p2 `ᵥ⊛ᵣ r_cover_r cover_cat) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A3 ⊕ B1)
o: pat (`- (A3 ⊕ B1)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A3 ⊕ B1); pr2 := POr1 p |} =
{| pr1 := (`- (A3 ⊕ B1)) †; pr2 := o |}
H2: `+ (A3 ⊕ B1),' POr1 p = (`- (A3 ⊕ B1)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A4 ⊕ B2)
o: pat (`- (A4 ⊕ B2)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (A4 ⊕ B2); pr2 := POr2 p |} =
{| pr1 := (`- (A4 ⊕ B2)) †; pr2 := o |}
H2: `+ (A4 ⊕ B2),' POr2 p = (`- (A4 ⊕ B2)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in OrR2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A5 & B3)
o: pat (`+ (A5 & B3)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A5 & B3); pr2 := PAnd1 p |} =
{| pr1 := (`+ (A5 & B3)) †; pr2 := o |}
H2: `- (A5 & B3),' PAnd1 p = (`+ (A5 & B3)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL1 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A6 & B4)
o: pat (`+ (A6 & B4)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (A6 & B4); pr2 := PAnd2 p |} =
{| pr1 := (`+ (A6 & B4)) †; pr2 := o |}
H2: `- (A6 & B4),' PAnd2 p = (`+ (A6 & B4)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in AndL2 p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- (↓ A7)
o: pat (`- (↓ A7)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (↓ A7); pr2 := PShiftP A7 |} =
{| pr1 := (`- (↓ A7)) †; pr2 := o |}
H1: `+ (↓ A7),' PShiftP A7 = (`- (↓ A7)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftPR (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ (↑ A8)
o: pat (`+ (↑ A8)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (↑ A8); pr2 := PShiftN A8 |} =
{| pr1 := (`+ (↑ A8)) †; pr2 := o |}
H1: `- (↑ A8),' PShiftN A8 = (`+ (↑ A8)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in ShiftNL (Whn (Var Ctx.top)) `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (⊖ A9)
o: pat (`- (⊖ A9)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `+ (⊖ A9); pr2 := PNegP p |} =
{| pr1 := (`- (⊖ A9)) †; pr2 := o |}
H2: `+ (⊖ A9),' PNegP p = (`- (⊖ A9)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegPR p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (¬ A10)
o: pat (`+ (¬ A10)) †
γ: dom o =[ val_n ]> Γ
eqargs: {| pr1 := `- (¬ A10); pr2 := PNegN p |} =
{| pr1 := (`+ (¬ A10)) †; pr2 := o |}
H2: `- (¬ A10),' PNegN p = (`+ (¬ A10)) †,' o
eval
  (Cut' (var i)
     (rew [fun projs : sigma (fun a : ty => pat a) =>
           whn (p_dom (pr2 projs)) (pr1 projs)]
          eqargs in NegNL p `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
    all: dependent destruction eqargs; cbn.Γ: neg_ctx
i: Γ ∋ `- 1
γ: dom POne =[ val_n ]> Γ
H1: `+ 1,' POne = (`- 1) †,' POne
eval (Cut pos (Whn OneR) (var i))
≋ ret_delay (i ⋅ POne ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ ⊥
γ: dom PBot =[ val_n ]> Γ
H1: `- ⊥,' PBot = (`+ ⊥) †,' PBot
eval (Cut neg (var i) (Whn BotL))
≋ ret_delay (i ⋅ PBot ⦇ γ ⦈)
A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A1 ⊗ B)
γ: dom (PTen p1 p2) =[ val_n ]> Γ
H3: `+ (A1 ⊗ B),' PTen p1 p2 =
(`- (A1 ⊗ B)) †,' PTen p1 p2
eval
  (Cut pos
     (Whn
        (TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
           (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ)))
     (var i)) ≋ ret_delay (i ⋅ PTen p1 p2 ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A2 ⅋ B0)
γ: dom (PPar p1 p2) =[ val_n ]> Γ
H3: `- (A2 ⅋ B0),' PPar p1 p2 =
(`+ (A2 ⅋ B0)) †,' PPar p1 p2
eval
  (Cut neg (var i)
     (Whn
        (ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
           (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ))))
≋ ret_delay (i ⋅ PPar p1 p2 ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A3 ⊕ B1)
γ: dom (POr1 p) =[ val_n ]> Γ
H2: `+ (A3 ⊕ B1),' POr1 p = (`- (A3 ⊕ B1)) †,' POr1 p
eval (Cut pos (Whn (OrR1 (p `ᵥ⊛ γ))) (var i))
≋ ret_delay (i ⋅ POr1 p ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A4 ⊕ B2)
γ: dom (POr2 p) =[ val_n ]> Γ
H2: `+ (A4 ⊕ B2),' POr2 p = (`- (A4 ⊕ B2)) †,' POr2 p
eval (Cut pos (Whn (OrR2 (p `ᵥ⊛ γ))) (var i))
≋ ret_delay (i ⋅ POr2 p ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A5 & B3)
γ: dom (PAnd1 p) =[ val_n ]> Γ
H2: `- (A5 & B3),' PAnd1 p =
(`+ (A5 & B3)) †,' PAnd1 p
eval (Cut neg (var i) (Whn (AndL1 (p `ᵥ⊛ γ))))
≋ ret_delay (i ⋅ PAnd1 p ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A6 & B4)
γ: dom (PAnd2 p) =[ val_n ]> Γ
H2: `- (A6 & B4),' PAnd2 p =
(`+ (A6 & B4)) †,' PAnd2 p
eval (Cut neg (var i) (Whn (AndL2 (p `ᵥ⊛ γ))))
≋ ret_delay (i ⋅ PAnd2 p ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- (↓ A7)
γ: dom (PShiftP A7) =[ val_n ]> Γ
H1: `+ (↓ A7),' PShiftP A7 =
(`- (↓ A7)) †,' PShiftP A7
eval
  (Cut pos (Whn (ShiftPR (γ `+ A7 Ctx.top))) (var i))
≋ ret_delay (i ⋅ PShiftP A7 ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ (↑ A8)
γ: dom (PShiftN A8) =[ val_n ]> Γ
H1: `- (↑ A8),' PShiftN A8 =
(`+ (↑ A8)) †,' PShiftN A8
eval
  (Cut neg (var i) (Whn (ShiftNL (γ `- A8 Ctx.top))))
≋ ret_delay (i ⋅ PShiftN A8 ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (⊖ A9)
γ: dom (PNegP p) =[ val_n ]> Γ
H2: `+ (⊖ A9),' PNegP p = (`- (⊖ A9)) †,' PNegP p
eval (Cut pos (Whn (NegPR (p `ᵥ⊛ γ))) (var i))
≋ ret_delay (i ⋅ PNegP p ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (¬ A10)
γ: dom (PNegN p) =[ val_n ]> Γ
H2: `- (¬ A10),' PNegN p = (`+ (¬ A10)) †,' PNegN p
eval (Cut neg (var i) (Whn (NegNL (p `ᵥ⊛ γ))))
≋ ret_delay (i ⋅ PNegN p ⦇ γ ⦈)
    all: apply it_eq_unstep; cbn -[w_of_p]; econstructor.Γ: neg_ctx
i: Γ ∋ `- 1
γ: dom POne =[ val_n ]> Γ
H1: `+ 1,' POne = (`- 1) †,' POne
nf_eq (s_var_upg i ⋅ v_split_p OneR) (i ⋅ POne ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ ⊥
γ: dom PBot =[ val_n ]> Γ
H1: `- ⊥,' PBot = (`+ ⊥) †,' PBot
nf_eq (s_var_upg i ⋅ v_split_n BotL) (i ⋅ PBot ⦇ γ ⦈)
A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A1 ⊗ B)
γ: dom (PTen p1 p2) =[ val_n ]> Γ
H3: `+ (A1 ⊗ B),' PTen p1 p2 =
(`- (A1 ⊗ B)) †,' PTen p1 p2
nf_eq
  (s_var_upg i
   ⋅ v_split_p
       (TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
          (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ)))
  (i ⋅ PTen p1 p2 ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A2 ⅋ B0)
γ: dom (PPar p1 p2) =[ val_n ]> Γ
H3: `- (A2 ⅋ B0),' PPar p1 p2 =
(`+ (A2 ⅋ B0)) †,' PPar p1 p2
nf_eq
  (s_var_upg i
   ⋅ v_split_n
       (ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
          (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ)))
  (i ⋅ PPar p1 p2 ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A3 ⊕ B1)
γ: dom (POr1 p) =[ val_n ]> Γ
H2: `+ (A3 ⊕ B1),' POr1 p = (`- (A3 ⊕ B1)) †,' POr1 p
nf_eq (s_var_upg i ⋅ v_split_p (OrR1 (p `ᵥ⊛ γ)))
  (i ⋅ POr1 p ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A4 ⊕ B2)
γ: dom (POr2 p) =[ val_n ]> Γ
H2: `+ (A4 ⊕ B2),' POr2 p = (`- (A4 ⊕ B2)) †,' POr2 p
nf_eq (s_var_upg i ⋅ v_split_p (OrR2 (p `ᵥ⊛ γ)))
  (i ⋅ POr2 p ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A5 & B3)
γ: dom (PAnd1 p) =[ val_n ]> Γ
H2: `- (A5 & B3),' PAnd1 p =
(`+ (A5 & B3)) †,' PAnd1 p
nf_eq (s_var_upg i ⋅ v_split_n (AndL1 (p `ᵥ⊛ γ)))
  (i ⋅ PAnd1 p ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A6 & B4)
γ: dom (PAnd2 p) =[ val_n ]> Γ
H2: `- (A6 & B4),' PAnd2 p =
(`+ (A6 & B4)) †,' PAnd2 p
nf_eq (s_var_upg i ⋅ v_split_n (AndL2 (p `ᵥ⊛ γ)))
  (i ⋅ PAnd2 p ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- (↓ A7)
γ: dom (PShiftP A7) =[ val_n ]> Γ
H1: `+ (↓ A7),' PShiftP A7 =
(`- (↓ A7)) †,' PShiftP A7
nf_eq
  (s_var_upg i ⋅ v_split_p (ShiftPR (γ `+ A7 Ctx.top)))
  (i ⋅ PShiftP A7 ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ (↑ A8)
γ: dom (PShiftN A8) =[ val_n ]> Γ
H1: `- (↑ A8),' PShiftN A8 =
(`+ (↑ A8)) †,' PShiftN A8
nf_eq
  (s_var_upg i ⋅ v_split_n (ShiftNL (γ `- A8 Ctx.top)))
  (i ⋅ PShiftN A8 ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (⊖ A9)
γ: dom (PNegP p) =[ val_n ]> Γ
H2: `+ (⊖ A9),' PNegP p = (`- (⊖ A9)) †,' PNegP p
nf_eq (s_var_upg i ⋅ v_split_p (NegPR (p `ᵥ⊛ γ)))
  (i ⋅ PNegP p ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (¬ A10)
γ: dom (PNegN p) =[ val_n ]> Γ
H2: `- (¬ A10),' PNegN p = (`+ (¬ A10)) †,' PNegN p
nf_eq (s_var_upg i ⋅ v_split_n (NegNL (p `ᵥ⊛ γ)))
  (i ⋅ PNegN p ⦇ γ ⦈)
    1-2: now econstructor.A1, B: pre_ty pos
p1: pat `+ A1
p2: pat `+ B
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A1; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A1 ⊗ B)
γ: dom (PTen p1 p2) =[ val_n ]> Γ
H3: `+ (A1 ⊗ B),' PTen p1 p2 =
(`- (A1 ⊗ B)) †,' PTen p1 p2
nf_eq
  (s_var_upg i
   ⋅ v_split_p
       (TenR (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
          (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ)))
  (i ⋅ PTen p1 p2 ⦇ γ ⦈)
A2, B0: pre_ty neg
p1: pat `- A2
p2: pat `- B0
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A2; pr2 := p1 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p1 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
H0: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B0; pr2 := p2 |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p2 = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A2 ⅋ B0)
γ: dom (PPar p1 p2) =[ val_n ]> Γ
H3: `- (A2 ⅋ B0),' PPar p1 p2 =
(`+ (A2 ⅋ B0)) †,' PPar p1 p2
nf_eq
  (s_var_upg i
   ⋅ v_split_n
       (ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ γ)
          (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ γ)))
  (i ⋅ PPar p1 p2 ⦇ γ ⦈)
A3, B1: pre_ty pos
p: pat `+ A3
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A3; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A3 ⊕ B1)
γ: dom (POr1 p) =[ val_n ]> Γ
H2: `+ (A3 ⊕ B1),' POr1 p = (`- (A3 ⊕ B1)) †,' POr1 p
nf_eq (s_var_upg i ⋅ v_split_p (OrR1 (p `ᵥ⊛ γ)))
  (i ⋅ POr1 p ⦇ γ ⦈)
A4, B2: pre_ty pos
p: pat `+ B2
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ B2; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (A4 ⊕ B2)
γ: dom (POr2 p) =[ val_n ]> Γ
H2: `+ (A4 ⊕ B2),' POr2 p = (`- (A4 ⊕ B2)) †,' POr2 p
nf_eq (s_var_upg i ⋅ v_split_p (OrR2 (p `ᵥ⊛ γ)))
  (i ⋅ POr2 p ⦇ γ ⦈)
A5, B3: pre_ty neg
p: pat `- A5
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A5; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A5 & B3)
γ: dom (PAnd1 p) =[ val_n ]> Γ
H2: `- (A5 & B3),' PAnd1 p =
(`+ (A5 & B3)) †,' PAnd1 p
nf_eq (s_var_upg i ⋅ v_split_n (AndL1 (p `ᵥ⊛ γ)))
  (i ⋅ PAnd1 p ⦇ γ ⦈)
A6, B4: pre_ty neg
p: pat `- B4
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- B4; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (A6 & B4)
γ: dom (PAnd2 p) =[ val_n ]> Γ
H2: `- (A6 & B4),' PAnd2 p =
(`+ (A6 & B4)) †,' PAnd2 p
nf_eq (s_var_upg i ⋅ v_split_n (AndL2 (p `ᵥ⊛ γ)))
  (i ⋅ PAnd2 p ⦇ γ ⦈)
A7: pre_ty neg
Γ: neg_ctx
i: Γ ∋ `- (↓ A7)
γ: dom (PShiftP A7) =[ val_n ]> Γ
H1: `+ (↓ A7),' PShiftP A7 =
(`- (↓ A7)) †,' PShiftP A7
nf_eq
  (s_var_upg i ⋅ v_split_p (ShiftPR (γ `+ A7 Ctx.top)))
  (i ⋅ PShiftP A7 ⦇ γ ⦈)
A8: pre_ty pos
Γ: neg_ctx
i: Γ ∋ `+ (↑ A8)
γ: dom (PShiftN A8) =[ val_n ]> Γ
H1: `- (↑ A8),' PShiftN A8 =
(`+ (↑ A8)) †,' PShiftN A8
nf_eq
  (s_var_upg i ⋅ v_split_n (ShiftNL (γ `- A8 Ctx.top)))
  (i ⋅ PShiftN A8 ⦇ γ ⦈)
A9: pre_ty neg
p: pat `- A9
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `- A9; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `- (⊖ A9)
γ: dom (PNegP p) =[ val_n ]> Γ
H2: `+ (⊖ A9),' PNegP p = (`- (⊖ A9)) †,' PNegP p
nf_eq (s_var_upg i ⋅ v_split_p (NegPR (p `ᵥ⊛ γ)))
  (i ⋅ PNegP p ⦇ γ ⦈)
A10: pre_ty pos
p: pat `+ A10
H: forall (Γ : neg_ctx) (A : ty) 
  (i : Γ ∋ A) (o : pat A †)
  (γ : dom o =[ val_n ]> Γ)
  (eqargs : {| pr1 := `+ A10; pr2 := p |} =
            {| pr1 := A †; pr2 := o |}),
rew [fun projs : sigma (fun a : ty => pat a) =>
     whn (p_dom (pr2 projs)) (pr1 projs)]
    eqargs in p = o ->
eval (Cut' (var i) (o `ᵥ⊛ γ))
≋ ret_delay (i ⋅ o ⦇ γ ⦈)
Γ: neg_ctx
i: Γ ∋ `+ (¬ A10)
γ: dom (PNegN p) =[ val_n ]> Γ
H2: `- (¬ A10),' PNegN p = (`+ (¬ A10)) †,' PNegN p
nf_eq (s_var_upg i ⋅ v_split_n (NegNL (p `ᵥ⊛ γ)))
  (i ⋅ PNegN p ⦇ γ ⦈)
    all: match goal with
         | γ : dom ?p =[val_n]> _ |- _ => first [ exact (nf_eq_split_p _ p γ)
                                              | exact (nf_eq_split_n _ p γ) ]
         end.

Finally we prove the finite chain property. The proof here is quite tedious again, with numerous cases, but it is still by brutally walking through the structure of one-step evaluation and finding the needed redex.

  -well_founded head_inst_nostep intros A; econstructor; intros [ B m ] H; dependent elimination H;
      cbn [projT1 projT2] in i, i0.y: ty
o: obs_op y
B: ty
m: obs_op 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 as [ [] | [] ].p: pre_ty pos
o: obs_op `+ p
B: ty
m: obs_op 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 neg
o: obs_op `+ p
B: ty
m: obs_op 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 pos
o: obs_op `- p
B: ty
m: obs_op 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 neg
o: obs_op `- p
B: ty
m: obs_op 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 _)).o: obs_op `+ 1
B: ty
m: obs_op B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var OneR -> T0
i0: evalₒ (OneR ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
o: obs_op `+ (A0 ⊗ B0)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (TenR w w0) -> T0
i0: evalₒ (TenR w w0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
o: obs_op `+ (A4 ⊕ B4)
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (OrR1 w3) -> T0
i0: evalₒ (OrR1 w3 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
o: obs_op `+ (A5 ⊕ B5)
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (OrR2 w4) -> T0
i0: evalₒ (OrR2 w4 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
o: obs_op `+ (↓ A10)
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (ShiftPR t1) -> T0
i0: evalₒ (ShiftPR t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
o: obs_op `+ (⊖ A14)
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (NegPR w7) -> T0
i0: evalₒ (NegPR w7 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty neg
o: obs_op `+ p
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ p) †)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Mu s) -> T0
i0: evalₒ (Mu s ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1: pre_ty neg
o: obs_op `+ A1
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ A1) `+ A1
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (RecR t2) -> T0
i0: evalₒ (RecR t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty neg
o: obs_op `+ p
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty pos
o: obs_op `- p
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- p) †)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Mu s) -> T0
i0: evalₒ (Mu s ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0: pre_ty pos
o: obs_op `- A0
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- A0) `- A0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (RecL t1) -> T0
i0: evalₒ (RecL t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty pos
o: obs_op `- p
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: obs_op `- ⊥
B: ty
m: obs_op B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var BotL -> T0
i0: evalₒ (BotL ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
o: obs_op `- (A3 ⅋ B3)
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (ParL w1 w2) -> T0
i0: evalₒ (ParL w1 w2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
o: obs_op `- (A8 & B8)
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (AndL1 w5) -> T0
i0: evalₒ (AndL1 w5 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
o: obs_op `- (A9 & B9)
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (AndL2 w6) -> T0
i0: evalₒ (AndL2 w6 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
o: obs_op `- (↑ A13)
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (ShiftNL t2) -> T0
i0: evalₒ (ShiftNL t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
o: obs_op `- (¬ A17)
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
t0: is_var (NegNL w8) -> T0
i0: evalₒ (NegNL w8 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: clear t0.o: obs_op `+ 1
B: ty
m: obs_op B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (OneR ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
o: obs_op `+ (A0 ⊗ B0)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (TenR w w0 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
o: obs_op `+ (A4 ⊕ B4)
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (OrR1 w3 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
o: obs_op `+ (A5 ⊕ B5)
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (OrR2 w4 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
o: obs_op `+ (↓ A10)
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (ShiftPR t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
o: obs_op `+ (⊖ A14)
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (NegPR w7 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty neg
o: obs_op `+ p
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ p) †)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Mu s ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1: pre_ty neg
o: obs_op `+ A1
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ A1) `+ A1
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (RecR t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty neg
o: obs_op `+ p
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Whn w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty pos
o: obs_op `- p
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- p) †)
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Mu s ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0: pre_ty pos
o: obs_op `- A0
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- A0) `- A0
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (RecL t1 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
p: pre_ty pos
o: obs_op `- p
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- p
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Whn w ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
o: obs_op `- ⊥
B: ty
m: obs_op B
Γ: neg_ctx
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (BotL ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
o: obs_op `- (A3 ⅋ B3)
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (ParL w1 w2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
o: obs_op `- (A8 & B8)
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (AndL1 w5 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
o: obs_op `- (A9 & B9)
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (AndL2 w6 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
o: obs_op `- (↑ A13)
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (ShiftNL t2 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
o: obs_op `- (¬ A17)
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
a: dom o =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (NegNL w8 ⊙ o ⦗ a ⦘) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: dependent elimination o; cbn in i0.B: ty
m: obs_op B
Γ: neg_ctx
a: dom (PVarN 1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (a `- 1 Ctx.top))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
a: dom (PVarN (A0 ⊗ B0)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (TenR w w0))
     (a `- (A0 ⊗ B0) Ctx.top))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
a: dom (PVarN (A4 ⊕ B4)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (OrR1 w3))
     (a `- (A4 ⊕ B4) Ctx.top))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
a: dom (PVarN (A5 ⊕ B5)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (OrR2 w4))
     (a `- (A5 ⊕ B5) Ctx.top))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
a: dom (PVarN (↓ A10)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (ShiftPR t1))
     (a `- (↓ A10) Ctx.top)) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
a: dom (PVarN ⊖ A14) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (NegPR w7))
     (a `- (⊖ A14) Ctx.top)) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ ⊥) †)
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A2 ⅋ B1)) †)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Mu s)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A5 & B4)) †)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A6 & B5)) †)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (↑ A8)) †)
a: dom (PShiftN A8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Mu s)
     (Whn (ShiftNL (a `- A8 Ctx.top))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (¬ A10)) †)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ ⊥) `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (RecR t2) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B1: pre_ty neg
p1: pat `- A3
p2: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A3 ⅋ B1)) `+ (A3 ⅋ B1)
a: dom (PPar p1 p2) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2)
     (Whn
        (ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B4: pre_ty neg
p5: pat `- A6
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A6 & B4)) `+ (A6 & B4)
a: dom (PAnd1 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (AndL1 (p5 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7, B5: pre_ty neg
p6: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A7 & B5)) `+ (A7 & B5)
a: dom (PAnd2 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (AndL2 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (↑ A9)) `+ (↑ A9)
a: dom (PShiftN A9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2)
     (Whn (ShiftNL (a `- A9 Ctx.top))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A11: pre_ty pos
p8: pat `+ A11
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (¬ A11)) `+ (¬ A11)
a: dom (PNegN p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (NegNL (p8 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn w)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (↑ A8)
a: dom (PShiftN A8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn w)
     (Whn (ShiftNL (a `- A8 Ctx.top))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- 1) †)
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A1 ⊗ B0)) †)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Mu s)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A3 ⊕ B2)) †)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A4 ⊕ B3)) †)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (↓ A7)) †)
a: dom (PShiftP A7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (ShiftPR (a `+ A7 Ctx.top)))
     (Mu s)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (⊖ A9)) †)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- 1) `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B0: pre_ty pos
p: pat `+ A2
p0: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A2 ⊗ B0)) `- (A2 ⊗ B0)
a: dom (PTen p p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p0 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (RecL t1)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B2: pre_ty pos
p3: pat `+ A4
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A4 ⊕ B2)) `- (A4 ⊕ B2)
a: dom (POr1 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p3 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B3: pre_ty pos
p4: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A5 ⊕ B3)) `- (A5 ⊕ B3)
a: dom (POr2 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p4 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (↓ A8)) `- (↓ A8)
a: dom (PShiftP A8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (ShiftPR (a `+ A8 Ctx.top)))
     (RecL t1)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
p7: pat `- A10
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (⊖ A10)) `- (⊖ A10)
a: dom (PNegP p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (NegPR (p7 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Whn w)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (↓ A7)
a: dom (PShiftP A7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (ShiftPR (a `+ A7 Ctx.top)))
     (Whn w)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
a: dom (PVarP ⊥) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (a `+ ⊥ Ctx.top) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
a: dom (PVarP (A3 ⅋ B3)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (a `+ (A3 ⅋ B3) Ctx.top)
     (Whn (ParL w1 w2))) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
a: dom (PVarP (A8 & B8)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (a `+ (A8 & B8) Ctx.top)
     (Whn (AndL1 w5))) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
a: dom (PVarP (A9 & B9)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (a `+ (A9 & B9) Ctx.top)
     (Whn (AndL2 w6))) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
a: dom (PVarP (↑ A13)) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (a `+ (↑ A13) Ctx.top)
     (Whn (ShiftNL t2))) ≊ 
ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
a: dom (PVarP ¬ A17) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (a `+ (¬ A17) Ctx.top)
     (Whn (NegNL w8))) ≊ 
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.B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
v': term Γ `- 1
i0: evalₒ (Cut pos (Whn OneR) v') ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
i: Γ ∋ B
v': term Γ `- (A0 ⊗ B0)
i0: evalₒ (Cut pos (Whn (TenR w w0)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
i: Γ ∋ B
v': term Γ `- (A4 ⊕ B4)
i0: evalₒ (Cut pos (Whn (OrR1 w3)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
i: Γ ∋ B
v': term Γ `- (A5 ⊕ B5)
i0: evalₒ (Cut pos (Whn (OrR2 w4)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
i: Γ ∋ B
v': term Γ `- (↓ A10)
i0: evalₒ (Cut pos (Whn (ShiftPR t1)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
i: Γ ∋ B
v': term Γ `- (⊖ A14)
i0: evalₒ (Cut pos (Whn (NegPR w7)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ ⊥) †)
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A2 ⅋ B1)) †)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Mu s)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A5 & B4)) †)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (A6 & B5)) †)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (↑ A8)) †)
i: Γ ∋ B
v': term Γ `- A8
i0: evalₒ (Cut neg (Mu s) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`+ (¬ A10)) †)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Mu s) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ ⊥) `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (RecR t2) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B1: pre_ty neg
p1: pat `- A3
p2: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A3 ⅋ B1)) `+ (A3 ⅋ B1)
a: dom (PPar p1 p2) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2)
     (Whn
        (ParL (p1 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p2 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B4: pre_ty neg
p5: pat `- A6
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A6 & B4)) `+ (A6 & B4)
a: dom (PAnd1 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (AndL1 (p5 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7, B5: pre_ty neg
p6: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (A7 & B5)) `+ (A7 & B5)
a: dom (PAnd2 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (AndL2 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (↑ A9)) `+ (↑ A9)
i: Γ ∋ B
v': term Γ `- A9
i0: evalₒ (Cut neg (RecR t2) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A11: pre_ty pos
p8: pat `+ A11
B: ty
m: obs_op B
Γ: neg_ctx
t2: term (Γ ▶ₓ `+ (¬ A11)) `+ (¬ A11)
a: dom (PNegN p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (RecR t2) (Whn (NegNL (p8 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn w)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (↑ A8)
i: Γ ∋ B
v': term Γ `- A8
i0: evalₒ (Cut neg (Whn w) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- 1) †)
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A1 ⊗ B0)) †)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Mu s)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A3 ⊕ B2)) †)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (A4 ⊕ B3)) †)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (↓ A7)) †)
i: Γ ∋ B
v': term Γ `+ A7
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
s: state (Γ ▶ₓ (`- (⊖ A9)) †)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Mu s))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- 1) `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B0: pre_ty pos
p: pat `+ A2
p0: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A2 ⊗ B0)) `- (A2 ⊗ B0)
a: dom (PTen p p0) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p0 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (RecL t1)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B2: pre_ty pos
p3: pat `+ A4
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A4 ⊕ B2)) `- (A4 ⊕ B2)
a: dom (POr1 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p3 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B3: pre_ty pos
p4: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (A5 ⊕ B3)) `- (A5 ⊕ B3)
a: dom (POr2 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p4 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (↓ A8)) `- (↓ A8)
i: Γ ∋ B
v': term Γ `+ A8
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
p7: pat `- A10
B: ty
m: obs_op B
Γ: neg_ctx
t1: term (Γ ▶ₓ `- (⊖ A10)) `- (⊖ A10)
a: dom (PNegP p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (NegPR (p7 `ᵥ⊛ a))) (RecL t1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Whn w)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (↓ A7)
i: Γ ∋ B
v': term Γ `+ A7
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
v': term Γ `+ ⊥
i0: evalₒ (Cut neg v' (Whn BotL)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
i: Γ ∋ B
v': term Γ `+ (A3 ⅋ B3)
i0: evalₒ (Cut neg v' (Whn (ParL w1 w2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
i: Γ ∋ B
v': term Γ `+ (A8 & B8)
i0: evalₒ (Cut neg v' (Whn (AndL1 w5)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
i: Γ ∋ B
v': term Γ `+ (A9 & B9)
i0: evalₒ (Cut neg v' (Whn (AndL2 w6)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
i: Γ ∋ B
v': term Γ `+ (↑ A13)
i0: evalₒ (Cut neg v' (Whn (ShiftNL t2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
i: Γ ∋ B
v': term Γ `+ (¬ A17)
i0: evalₒ (Cut neg v' (Whn (NegNL w8)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    7-18,25-36: apply it_eq_step in i0; now inversion i0.B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
v': term Γ `- 1
i0: evalₒ (Cut pos (Whn OneR) v') ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
i: Γ ∋ B
v': term Γ `- (A0 ⊗ B0)
i0: evalₒ (Cut pos (Whn (TenR w w0)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
i: Γ ∋ B
v': term Γ `- (A4 ⊕ B4)
i0: evalₒ (Cut pos (Whn (OrR1 w3)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
i: Γ ∋ B
v': term Γ `- (A5 ⊕ B5)
i0: evalₒ (Cut pos (Whn (OrR2 w4)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
i: Γ ∋ B
v': term Γ `- (↓ A10)
i0: evalₒ (Cut pos (Whn (ShiftPR t1)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
i: Γ ∋ B
v': term Γ `- (⊖ A14)
i0: evalₒ (Cut pos (Whn (NegPR w7)) v')
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn w)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (↑ A8)
i: Γ ∋ B
v': term Γ `- A8
i0: evalₒ (Cut neg (Whn w) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Whn w)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (↓ A7)
i: Γ ∋ B
v': term Γ `+ A7
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
v': term Γ `+ ⊥
i0: evalₒ (Cut neg v' (Whn BotL)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
i: Γ ∋ B
v': term Γ `+ (A3 ⅋ B3)
i0: evalₒ (Cut neg v' (Whn (ParL w1 w2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
i: Γ ∋ B
v': term Γ `+ (A8 & B8)
i0: evalₒ (Cut neg v' (Whn (AndL1 w5)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
i: Γ ∋ B
v': term Γ `+ (A9 & B9)
i0: evalₒ (Cut neg v' (Whn (AndL2 w6)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
i: Γ ∋ B
v': term Γ `+ (↑ A13)
i0: evalₒ (Cut neg v' (Whn (ShiftNL t2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
i: Γ ∋ B
v': term Γ `+ (¬ A17)
i0: evalₒ (Cut neg v' (Whn (NegNL w8)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    1-9,19-24: match goal with
       | t : term _ _ |- _ =>
           dependent elimination t;
           [ apply it_eq_step in i0; now inversion i0
           | apply it_eq_step in i0; now inversion i0
           | ]
       | _ => idtac
         end.B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
w: whn Γ `- 1
i0: evalₒ (Cut pos (Whn OneR) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
i: Γ ∋ B
w1: whn Γ `- (A0 ⊗ B0)
i0: evalₒ (Cut pos (Whn (TenR w w0)) (Whn w1))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
i: Γ ∋ B
w: whn Γ `- (A4 ⊕ B4)
i0: evalₒ (Cut pos (Whn (OrR1 w3)) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
i: Γ ∋ B
w: whn Γ `- (A5 ⊕ B5)
i0: evalₒ (Cut pos (Whn (OrR2 w4)) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
i: Γ ∋ B
w: whn Γ `- (↓ A10)
i0: evalₒ (Cut pos (Whn (ShiftPR t1)) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
i: Γ ∋ B
w: whn Γ `- (⊖ A14)
i0: evalₒ (Cut pos (Whn (NegPR w7)) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn w)
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
w: whn Γ `+ ⊥
i0: evalₒ (Cut neg (Whn w) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
i: Γ ∋ B
w: whn Γ `+ (A3 ⅋ B3)
i0: evalₒ (Cut neg (Whn w) (Whn (ParL w1 w2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
i: Γ ∋ B
w: whn Γ `+ (A8 & B8)
i0: evalₒ (Cut neg (Whn w) (Whn (AndL1 w5)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
i: Γ ∋ B
w: whn Γ `+ (A9 & B9)
i0: evalₒ (Cut neg (Whn w) (Whn (AndL2 w6)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
i: Γ ∋ B
w: whn Γ `+ (↑ A13)
i0: evalₒ (Cut neg (Whn w) (Whn (ShiftNL t2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
i: Γ ∋ B
w: whn Γ `+ (¬ A17)
i0: evalₒ (Cut neg (Whn w) (Whn (NegNL w8)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (↑ A8)
i: Γ ∋ B
v': term Γ `- A8
i0: evalₒ (Cut neg (Whn w) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn w) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Whn w)) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (↓ A7)
i: Γ ∋ B
v': term Γ `+ A7
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Whn w))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
    all: 
      match goal with
      | t : evalₒ (Cut _ (Whn ?w) _) ≊ _ |- _ =>
          dependent elimination w;
          [ | apply it_eq_step in i0; now inversion i0 ]
      | t : evalₒ (Cut _ _ (Whn ?w)) ≊ _ |- _ =>
          dependent elimination w;
          [ | apply it_eq_step in i0; now inversion i0 ]
      | _ => idtac
      end.B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
c: Γ ∋ `- 1
i0: evalₒ (Cut pos (Whn OneR) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A0, B0: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
i: Γ ∋ B
c: Γ ∋ `- (A0 ⊗ B0)
i0: evalₒ (Cut pos (Whn (TenR w w0)) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B4: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w3: whn Γ `+ A4
i: Γ ∋ B
c: Γ ∋ `- (A4 ⊕ B4)
i0: evalₒ (Cut pos (Whn (OrR1 w3)) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B5: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w4: whn Γ `+ B5
i: Γ ∋ B
c: Γ ∋ `- (A5 ⊕ B5)
i0: evalₒ (Cut pos (Whn (OrR2 w4)) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
t1: term Γ `+ A10
i: Γ ∋ B
c: Γ ∋ `- (↓ A10)
i0: evalₒ (Cut pos (Whn (ShiftPR t1)) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A14: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w7: whn Γ `- A14
i: Γ ∋ B
c: Γ ∋ `- (⊖ A14)
i0: evalₒ (Cut pos (Whn (NegPR w7)) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ ⊥
a: dom PBot =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut neg (Whn (Var c)) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn (Var c))
     (Whn
        (ParL (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A5, B4: pre_ty neg
p6: pat `- A5
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn (Var c)) (Whn (AndL1 (p6 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
i: Γ ∋ B
c: Γ ∋ `+ ⊥
i0: evalₒ (Cut neg (Whn (Var c)) (Whn BotL))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B3: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
i: Γ ∋ B
c: Γ ∋ `+ (A3 ⅋ B3)
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (ParL w1 w2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8, B8: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w5: whn Γ `- A8
i: Γ ∋ B
c: Γ ∋ `+ (A8 & B8)
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (AndL1 w5)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9, B9: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
w6: whn Γ `- B9
i: Γ ∋ B
c: Γ ∋ `+ (A9 & B9)
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (AndL2 w6)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A13: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
t2: term Γ `- A13
i: Γ ∋ B
c: Γ ∋ `+ (↑ A13)
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (ShiftNL t2)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A17: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
w8: whn Γ `+ A17
i: Γ ∋ B
c: Γ ∋ `+ (¬ A17)
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (NegNL w8)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A6, B5: pre_ty neg
p7: pat `- B5
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn (Var c)) (Whn (AndL2 (p7 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A8: pre_ty pos
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ (↑ A8)
i: Γ ∋ B
v': term Γ `- A8
i0: evalₒ (Cut neg (Whn (Var c)) (Whn (ShiftNL v')))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A10: pre_ty pos
p9: pat `+ A10
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut neg (Whn (Var c)) (Whn (NegNL (p9 `ᵥ⊛ a))))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- 1
a: dom POne =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ (Cut pos (Whn OneR) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos
     (Whn
        (TenR (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a)
           (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
     (Whn (Var c))) ≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A3, B2: pre_ty pos
p4: pat `+ A3
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (OrR1 (p4 `ᵥ⊛ a))) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A4, B3: pre_ty pos
p5: pat `+ B3
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (OrR2 (p5 `ᵥ⊛ a))) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A7: pre_ty neg
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- (↓ A7)
i: Γ ∋ B
v': term Γ `+ A7
i0: evalₒ (Cut pos (Whn (ShiftPR v')) (Whn (Var c)))
≊ ret_delay (i ⋅ m)
Acc head_inst_nostep (B,' m)
A9: pre_ty neg
p8: pat `- A9
B: ty
m: obs_op B
Γ: neg_ctx
c: Γ ∋ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
i: Γ ∋ B
i0: evalₒ
  (Cut pos (Whn (NegPR (p8 `ᵥ⊛ a))) (Whn (Var c)))
≊ 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 v_split_n,v_split_p 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.Γ: neg_ctx
c: Γ ∋ `- 1
Acc head_inst_nostep (`- 1,' POne)
A0, B0: pre_ty pos
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
c: Γ ∋ `- (A0 ⊗ B0)
Acc head_inst_nostep
  (`- (A0 ⊗ B0),'
   PTen (p_of_w_0p A0 w) (p_of_w_0p B0 w0))
A4, B4: pre_ty pos
Γ: neg_ctx
w3: whn Γ `+ A4
c: Γ ∋ `- (A4 ⊕ B4)
Acc head_inst_nostep
  (`- (A4 ⊕ B4),' POr1 (p_of_w_0p A4 w3))
A5, B5: pre_ty pos
Γ: neg_ctx
w4: whn Γ `+ B5
c: Γ ∋ `- (A5 ⊕ B5)
Acc head_inst_nostep
  (`- (A5 ⊕ B5),' POr2 (p_of_w_0p B5 w4))
A10: pre_ty neg
Γ: neg_ctx
t1: term Γ `+ A10
c: Γ ∋ `- (↓ A10)
Acc head_inst_nostep (`- (↓ A10),' PShiftP A10)
A14: pre_ty neg
Γ: neg_ctx
w7: whn Γ `- A14
c: Γ ∋ `- (⊖ A14)
Acc head_inst_nostep
  (`- (⊖ A14),' PNegP (p_of_w_0n A14 w7))
Γ: neg_ctx
c: Γ ∋ `+ ⊥
a: dom PBot =[ val_n ]> Γ
Acc head_inst_nostep (`+ ⊥,' PBot)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
Γ: neg_ctx
c: Γ ∋ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
Acc head_inst_nostep
  (`+ (A2 ⅋ B1),'
   PPar
     (p_of_w_0n A2 (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0n B1 (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
A5, B4: pre_ty neg
p6: pat `- A5
Γ: neg_ctx
c: Γ ∋ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
Acc head_inst_nostep
  (`+ (A5 & B4),' PAnd1 (p_of_w_0n A5 (p6 `ᵥ⊛ a)))
Γ: neg_ctx
c: Γ ∋ `+ ⊥
Acc head_inst_nostep (`+ ⊥,' PBot)
A3, B3: pre_ty neg
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
c: Γ ∋ `+ (A3 ⅋ B3)
Acc head_inst_nostep
  (`+ (A3 ⅋ B3),'
   PPar (p_of_w_0n A3 w1) (p_of_w_0n B3 w2))
A8, B8: pre_ty neg
Γ: neg_ctx
w5: whn Γ `- A8
c: Γ ∋ `+ (A8 & B8)
Acc head_inst_nostep
  (`+ (A8 & B8),' PAnd1 (p_of_w_0n A8 w5))
A9, B9: pre_ty neg
Γ: neg_ctx
w6: whn Γ `- B9
c: Γ ∋ `+ (A9 & B9)
Acc head_inst_nostep
  (`+ (A9 & B9),' PAnd2 (p_of_w_0n B9 w6))
A13: pre_ty pos
Γ: neg_ctx
t2: term Γ `- A13
c: Γ ∋ `+ (↑ A13)
Acc head_inst_nostep (`+ (↑ A13),' PShiftN A13)
A17: pre_ty pos
Γ: neg_ctx
w8: whn Γ `+ A17
c: Γ ∋ `+ (¬ A17)
Acc head_inst_nostep
  (`+ (¬ A17),' PNegN (p_of_w_0p A17 w8))
A6, B5: pre_ty neg
p7: pat `- B5
Γ: neg_ctx
c: Γ ∋ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
Acc head_inst_nostep
  (`+ (A6 & B5),' PAnd2 (p_of_w_0n B5 (p7 `ᵥ⊛ a)))
A8: pre_ty pos
Γ: neg_ctx
c: Γ ∋ `+ (↑ A8)
v': term Γ `- A8
Acc head_inst_nostep (`+ (↑ A8),' PShiftN A8)
A10: pre_ty pos
p9: pat `+ A10
Γ: neg_ctx
c: Γ ∋ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
Acc head_inst_nostep
  (`+ (¬ A10),' PNegN (p_of_w_0p A10 (p9 `ᵥ⊛ a)))
Γ: neg_ctx
c: Γ ∋ `- 1
a: dom POne =[ val_n ]> Γ
Acc head_inst_nostep (`- 1,' POne)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
Γ: neg_ctx
c: Γ ∋ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
Acc head_inst_nostep
  (`- (A1 ⊗ B0),'
   PTen
     (p_of_w_0p A1 (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0p B0 (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a)))
A3, B2: pre_ty pos
p4: pat `+ A3
Γ: neg_ctx
c: Γ ∋ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
Acc head_inst_nostep
  (`- (A3 ⊕ B2),' POr1 (p_of_w_0p A3 (p4 `ᵥ⊛ a)))
A4, B3: pre_ty pos
p5: pat `+ B3
Γ: neg_ctx
c: Γ ∋ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
Acc head_inst_nostep
  (`- (A4 ⊕ B3),' POr2 (p_of_w_0p B3 (p5 `ᵥ⊛ a)))
A7: pre_ty neg
Γ: neg_ctx
c: Γ ∋ `- (↓ A7)
v': term Γ `+ A7
Acc head_inst_nostep (`- (↓ A7),' PShiftP A7)
A9: pre_ty neg
p8: pat `- A9
Γ: neg_ctx
c: Γ ∋ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
Acc head_inst_nostep
  (`- (⊖ A9),' PNegP (p_of_w_0n A9 (p8 `ᵥ⊛ a)))
    all:
      econstructor; intros [ t o ] H; cbn in t,o; dependent elimination H;
      dependent elimination v;
      [ apply it_eq_step in i0; cbn in i0; now inversion i0
      | apply it_eq_step in i0; cbn in i0; now inversion i0 
      | ].Γ: neg_ctx
c: Γ ∋ `- 1
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- 1
a: dom POne =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ POne ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A0, B0: pre_ty pos
Γ: neg_ctx
w: whn Γ `+ A0
w0: whn Γ `+ B0
c: Γ ∋ `- (A0 ⊗ B0)
t: ty
o: pat t †
Γ0: neg_ctx
w1: whn Γ0 `- (A0 ⊗ B0)
a: dom (PTen (p_of_w_0p A0 w) (p_of_w_0p B0 w0)) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w1) -> T0
i0: evalₒ
  (Whn w1
   ⊙ PTen (p_of_w_0p A0 w) (p_of_w_0p B0 w0) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A4, B4: pre_ty pos
Γ: neg_ctx
w3: whn Γ `+ A4
c: Γ ∋ `- (A4 ⊕ B4)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (A4 ⊕ B4)
a: dom (POr1 (p_of_w_0p A4 w3)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ POr1 (p_of_w_0p A4 w3) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A5, B5: pre_ty pos
Γ: neg_ctx
w4: whn Γ `+ B5
c: Γ ∋ `- (A5 ⊕ B5)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (A5 ⊕ B5)
a: dom (POr2 (p_of_w_0p B5 w4)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ POr2 (p_of_w_0p B5 w4) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A10: pre_ty neg
Γ: neg_ctx
t1: term Γ `+ A10
c: Γ ∋ `- (↓ A10)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (↓ A10)
a: dom (PShiftP A10) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PShiftP A10 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A14: pre_ty neg
Γ: neg_ctx
w7: whn Γ `- A14
c: Γ ∋ `- (⊖ A14)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (⊖ A14)
a: dom (PNegP (p_of_w_0n A14 w7)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PNegP (p_of_w_0n A14 w7) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `+ ⊥
a: dom PBot =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ ⊥
a0: dom PBot =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PBot ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A2, B1: pre_ty neg
p2: pat `- A2
p3: pat `- B1
Γ: neg_ctx
c: Γ ∋ `+ (A2 ⅋ B1)
a: dom (PPar p2 p3) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A2 ⅋ B1)
a0: dom
  (PPar
     (p_of_w_0n A2
        (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0n B1
        (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w
   ⊙ PPar
       (p_of_w_0n A2
          (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
       (p_of_w_0n B1
          (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))
   ⦗ a0 ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A5, B4: pre_ty neg
p6: pat `- A5
Γ: neg_ctx
c: Γ ∋ `+ (A5 & B4)
a: dom (PAnd1 p6) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A5 & B4)
a0: dom (PAnd1 (p_of_w_0n A5 (p6 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ PAnd1 (p_of_w_0n A5 (p6 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `+ ⊥
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ ⊥
a: dom PBot =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PBot ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A3, B3: pre_ty neg
Γ: neg_ctx
w1: whn Γ `- A3
w2: whn Γ `- B3
c: Γ ∋ `+ (A3 ⅋ B3)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A3 ⅋ B3)
a: dom (PPar (p_of_w_0n A3 w1) (p_of_w_0n B3 w2)) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w
   ⊙ PPar (p_of_w_0n A3 w1) (p_of_w_0n B3 w2) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A8, B8: pre_ty neg
Γ: neg_ctx
w5: whn Γ `- A8
c: Γ ∋ `+ (A8 & B8)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A8 & B8)
a: dom (PAnd1 (p_of_w_0n A8 w5)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PAnd1 (p_of_w_0n A8 w5) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A9, B9: pre_ty neg
Γ: neg_ctx
w6: whn Γ `- B9
c: Γ ∋ `+ (A9 & B9)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A9 & B9)
a: dom (PAnd2 (p_of_w_0n B9 w6)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PAnd2 (p_of_w_0n B9 w6) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A13: pre_ty pos
Γ: neg_ctx
t2: term Γ `- A13
c: Γ ∋ `+ (↑ A13)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (↑ A13)
a: dom (PShiftN A13) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PShiftN A13 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A17: pre_ty pos
Γ: neg_ctx
w8: whn Γ `+ A17
c: Γ ∋ `+ (¬ A17)
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (¬ A17)
a: dom (PNegN (p_of_w_0p A17 w8)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PNegN (p_of_w_0p A17 w8) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A6, B5: pre_ty neg
p7: pat `- B5
Γ: neg_ctx
c: Γ ∋ `+ (A6 & B5)
a: dom (PAnd2 p7) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (A6 & B5)
a0: dom (PAnd2 (p_of_w_0n B5 (p7 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ PAnd2 (p_of_w_0n B5 (p7 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A8: pre_ty pos
Γ: neg_ctx
c: Γ ∋ `+ (↑ A8)
v': term Γ `- A8
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (↑ A8)
a: dom (PShiftN A8) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PShiftN A8 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A10: pre_ty pos
p9: pat `+ A10
Γ: neg_ctx
c: Γ ∋ `+ (¬ A10)
a: dom (PNegN p9) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `+ (¬ A10)
a0: dom (PNegN (p_of_w_0p A10 (p9 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ PNegN (p_of_w_0p A10 (p9 `ᵥ⊛ a)) ⦗ a0
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `- 1
a: dom POne =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- 1
a0: dom POne =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ POne ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A1, B0: pre_ty pos
p0: pat `+ A1
p1: pat `+ B0
Γ: neg_ctx
c: Γ ∋ `- (A1 ⊗ B0)
a: dom (PTen p0 p1) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (A1 ⊗ B0)
a0: dom
  (PTen
     (p_of_w_0p A1
        (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0p B0
        (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w
   ⊙ PTen
       (p_of_w_0p A1
          (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
       (p_of_w_0p B0
          (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))
   ⦗ a0 ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A3, B2: pre_ty pos
p4: pat `+ A3
Γ: neg_ctx
c: Γ ∋ `- (A3 ⊕ B2)
a: dom (POr1 p4) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (A3 ⊕ B2)
a0: dom (POr1 (p_of_w_0p A3 (p4 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ POr1 (p_of_w_0p A3 (p4 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A4, B3: pre_ty pos
p5: pat `+ B3
Γ: neg_ctx
c: Γ ∋ `- (A4 ⊕ B3)
a: dom (POr2 p5) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (A4 ⊕ B3)
a0: dom (POr2 (p_of_w_0p B3 (p5 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ POr2 (p_of_w_0p B3 (p5 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7: pre_ty neg
Γ: neg_ctx
c: Γ ∋ `- (↓ A7)
v': term Γ `+ A7
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (↓ A7)
a: dom (PShiftP A7) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ (Whn w ⊙ PShiftP A7 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A9: pre_ty neg
p8: pat `- A9
Γ: neg_ctx
c: Γ ∋ `- (⊖ A9)
a: dom (PNegP p8) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
w: whn Γ0 `- (⊖ A9)
a0: dom (PNegP (p_of_w_0n A9 (p8 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn w) -> T0
i0: evalₒ
  (Whn w ⊙ PNegP (p_of_w_0n A9 (p8 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
    all:
      match goal with
      | H : is_var (Whn ?w) -> _ |- _ =>
          dependent elimination w;
          try now destruct (H (Vvar _))
      end.Γ: neg_ctx
c: Γ ∋ `- 1
t: ty
o: pat t †
Γ0: neg_ctx
s: state Γ0
a: dom POne =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OneL s)) -> T0
i0: evalₒ (Whn (OneL s) ⊙ POne ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A2, B2: pre_ty pos
Γ: neg_ctx
w: whn Γ `+ A2
w0: whn Γ `+ B2
c: Γ ∋ `- (A2 ⊗ B2)
t: ty
o: pat t †
Γ0: neg_ctx
s1: state (Γ0 ▶ₓ `+ A2 ▶ₓ `+ B2)
a: dom (PTen (p_of_w_0p A2 w) (p_of_w_0p B2 w0)) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (TenL s1)) -> T0
i0: evalₒ
  (Whn (TenL s1)
   ⊙ PTen (p_of_w_0p A2 w) (p_of_w_0p B2 w0) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty pos
Γ: neg_ctx
w3: whn Γ `+ A7
c: Γ ∋ `- (A7 ⊕ B7)
t: ty
o: pat t †
Γ0: neg_ctx
s3: state (Γ0 ▶ₓ `+ A7)
s4: state (Γ0 ▶ₓ `+ B7)
a: dom (POr1 (p_of_w_0p A7 w3)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OrL s3 s4)) -> T0
i0: evalₒ
  (Whn (OrL s3 s4) ⊙ POr1 (p_of_w_0p A7 w3) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty pos
Γ: neg_ctx
w4: whn Γ `+ B7
c: Γ ∋ `- (A7 ⊕ B7)
t: ty
o: pat t †
Γ0: neg_ctx
s3: state (Γ0 ▶ₓ `+ A7)
s4: state (Γ0 ▶ₓ `+ B7)
a: dom (POr2 (p_of_w_0p B7 w4)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OrL s3 s4)) -> T0
i0: evalₒ
  (Whn (OrL s3 s4) ⊙ POr2 (p_of_w_0p B7 w4) ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A12: pre_ty neg
Γ: neg_ctx
t1: term Γ `+ A12
c: Γ ∋ `- (↓ A12)
t: ty
o: pat t †
Γ0: neg_ctx
s7: state (Γ0 ▶ₓ `+ A12)
a: dom (PShiftP A12) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ShiftPL s7)) -> T0
i0: evalₒ (Whn (ShiftPL s7) ⊙ PShiftP A12 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A16: pre_ty neg
Γ: neg_ctx
w7: whn Γ `- A16
c: Γ ∋ `- (⊖ A16)
t: ty
o: pat t †
Γ0: neg_ctx
s9: state (Γ0 ▶ₓ `- A16)
a: dom (PNegP (p_of_w_0n A16 w7)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (NegPL s9)) -> T0
i0: evalₒ
  (Whn (NegPL s9) ⊙ PNegP (p_of_w_0n A16 w7) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `+ ⊥
a: dom PBot =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s0: state Γ0
a0: dom PBot =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (BotR s0)) -> T0
i0: evalₒ (Whn (BotR s0) ⊙ PBot ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A3, B3: pre_ty neg
p2: pat `- A3
p3: pat `- B3
Γ: neg_ctx
c: Γ ∋ `+ (A3 ⅋ B3)
a: dom (PPar p2 p3) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s2: state (Γ0 ▶ₓ `- A3 ▶ₓ `- B3)
a0: dom
  (PPar
     (p_of_w_0n A3
        (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0n B3
        (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ParR s2)) -> T0
i0: evalₒ
  (Whn (ParR s2)
   ⊙ PPar
       (p_of_w_0n A3
          (p2 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
       (p_of_w_0n B3
          (p3 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))
   ⦗ a0 ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A8, B8: pre_ty neg
p6: pat `- A8
Γ: neg_ctx
c: Γ ∋ `+ (A8 & B8)
a: dom (PAnd1 p6) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s5: state (Γ0 ▶ₓ `- A8)
s6: state (Γ0 ▶ₓ `- B8)
a0: dom (PAnd1 (p_of_w_0n A8 (p6 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (AndR s5 s6)) -> T0
i0: evalₒ
  (Whn (AndR s5 s6)
   ⊙ PAnd1 (p_of_w_0n A8 (p6 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `+ ⊥
t: ty
o: pat t †
Γ0: neg_ctx
s0: state Γ0
a: dom PBot =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (BotR s0)) -> T0
i0: evalₒ (Whn (BotR s0) ⊙ PBot ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A2, B2: pre_ty neg
Γ: neg_ctx
w1: whn Γ `- A2
w2: whn Γ `- B2
c: Γ ∋ `+ (A2 ⅋ B2)
t: ty
o: pat t †
Γ0: neg_ctx
s2: state (Γ0 ▶ₓ `- A2 ▶ₓ `- B2)
a: dom (PPar (p_of_w_0n A2 w1) (p_of_w_0n B2 w2)) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ParR s2)) -> T0
i0: evalₒ
  (Whn (ParR s2)
   ⊙ PPar (p_of_w_0n A2 w1) (p_of_w_0n B2 w2) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty neg
Γ: neg_ctx
w5: whn Γ `- A7
c: Γ ∋ `+ (A7 & B7)
t: ty
o: pat t †
Γ0: neg_ctx
s5: state (Γ0 ▶ₓ `- A7)
s6: state (Γ0 ▶ₓ `- B7)
a: dom (PAnd1 (p_of_w_0n A7 w5)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (AndR s5 s6)) -> T0
i0: evalₒ
  (Whn (AndR s5 s6) ⊙ PAnd1 (p_of_w_0n A7 w5) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty neg
Γ: neg_ctx
w6: whn Γ `- B7
c: Γ ∋ `+ (A7 & B7)
t: ty
o: pat t †
Γ0: neg_ctx
s5: state (Γ0 ▶ₓ `- A7)
s6: state (Γ0 ▶ₓ `- B7)
a: dom (PAnd2 (p_of_w_0n B7 w6)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (AndR s5 s6)) -> T0
i0: evalₒ
  (Whn (AndR s5 s6) ⊙ PAnd2 (p_of_w_0n B7 w6) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A12: pre_ty pos
Γ: neg_ctx
t2: term Γ `- A12
c: Γ ∋ `+ (↑ A12)
t: ty
o: pat t †
Γ0: neg_ctx
s8: state (Γ0 ▶ₓ `- A12)
a: dom (PShiftN A12) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ShiftNR s8)) -> T0
i0: evalₒ (Whn (ShiftNR s8) ⊙ PShiftN A12 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A16: pre_ty pos
Γ: neg_ctx
w8: whn Γ `+ A16
c: Γ ∋ `+ (¬ A16)
t: ty
o: pat t †
Γ0: neg_ctx
s10: state (Γ0 ▶ₓ `+ A16)
a: dom (PNegN (p_of_w_0p A16 w8)) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (NegNR s10)) -> T0
i0: evalₒ
  (Whn (NegNR s10) ⊙ PNegN (p_of_w_0p A16 w8) ⦗ a
   ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A8, B8: pre_ty neg
p7: pat `- B8
Γ: neg_ctx
c: Γ ∋ `+ (A8 & B8)
a: dom (PAnd2 p7) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s5: state (Γ0 ▶ₓ `- A8)
s6: state (Γ0 ▶ₓ `- B8)
a0: dom (PAnd2 (p_of_w_0n B8 (p7 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (AndR s5 s6)) -> T0
i0: evalₒ
  (Whn (AndR s5 s6)
   ⊙ PAnd2 (p_of_w_0n B8 (p7 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A13: pre_ty pos
Γ: neg_ctx
c: Γ ∋ `+ (↑ A13)
v': term Γ `- A13
t: ty
o: pat t †
Γ0: neg_ctx
s8: state (Γ0 ▶ₓ `- A13)
a: dom (PShiftN A13) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ShiftNR s8)) -> T0
i0: evalₒ (Whn (ShiftNR s8) ⊙ PShiftN A13 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A17: pre_ty pos
p9: pat `+ A17
Γ: neg_ctx
c: Γ ∋ `+ (¬ A17)
a: dom (PNegN p9) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s10: state (Γ0 ▶ₓ `+ A17)
a0: dom (PNegN (p_of_w_0p A17 (p9 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (NegNR s10)) -> T0
i0: evalₒ
  (Whn (NegNR s10)
   ⊙ PNegN (p_of_w_0p A17 (p9 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
Γ: neg_ctx
c: Γ ∋ `- 1
a: dom POne =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s: state Γ0
a0: dom POne =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OneL s)) -> T0
i0: evalₒ (Whn (OneL s) ⊙ POne ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A2, B2: pre_ty pos
p0: pat `+ A2
p1: pat `+ B2
Γ: neg_ctx
c: Γ ∋ `- (A2 ⊗ B2)
a: dom (PTen p0 p1) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s1: state (Γ0 ▶ₓ `+ A2 ▶ₓ `+ B2)
a0: dom
  (PTen
     (p_of_w_0p A2
        (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
     (p_of_w_0p B2
        (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))) =[
val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (TenL s1)) -> T0
i0: evalₒ
  (Whn (TenL s1)
   ⊙ PTen
       (p_of_w_0p A2
          (p0 `ᵥ⊛ᵣ r_cover_l cover_cat `ᵥ⊛ a))
       (p_of_w_0p B2
          (p1 `ᵥ⊛ᵣ r_cover_r cover_cat `ᵥ⊛ a))
   ⦗ a0 ⦘) ≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty pos
p4: pat `+ A7
Γ: neg_ctx
c: Γ ∋ `- (A7 ⊕ B7)
a: dom (POr1 p4) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s3: state (Γ0 ▶ₓ `+ A7)
s4: state (Γ0 ▶ₓ `+ B7)
a0: dom (POr1 (p_of_w_0p A7 (p4 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OrL s3 s4)) -> T0
i0: evalₒ
  (Whn (OrL s3 s4)
   ⊙ POr1 (p_of_w_0p A7 (p4 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A7, B7: pre_ty pos
p5: pat `+ B7
Γ: neg_ctx
c: Γ ∋ `- (A7 ⊕ B7)
a: dom (POr2 p5) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s3: state (Γ0 ▶ₓ `+ A7)
s4: state (Γ0 ▶ₓ `+ B7)
a0: dom (POr2 (p_of_w_0p B7 (p5 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (OrL s3 s4)) -> T0
i0: evalₒ
  (Whn (OrL s3 s4)
   ⊙ POr2 (p_of_w_0p B7 (p5 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A12: pre_ty neg
Γ: neg_ctx
c: Γ ∋ `- (↓ A12)
v': term Γ `+ A12
t: ty
o: pat t †
Γ0: neg_ctx
s7: state (Γ0 ▶ₓ `+ A12)
a: dom (PShiftP A12) =[ val_n ]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (ShiftPL s7)) -> T0
i0: evalₒ (Whn (ShiftPL s7) ⊙ PShiftP A12 ⦗ a ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
A16: pre_ty neg
p8: pat `- A16
Γ: neg_ctx
c: Γ ∋ `- (⊖ A16)
a: dom (PNegP p8) =[ val_n ]> Γ
t: ty
o: pat t †
Γ0: neg_ctx
s9: state (Γ0 ▶ₓ `- A16)
a0: dom (PNegP (p_of_w_0n A16 (p8 `ᵥ⊛ a))) =[ val_n
]> Γ0
i: Γ0 ∋ projT1 (t,' o)
t0: is_var (Whn (NegPL s9)) -> T0
i0: evalₒ
  (Whn (NegPL s9)
   ⊙ PNegP (p_of_w_0n A16 (p8 `ᵥ⊛ a)) ⦗ a0 ⦘)
≊ ret_delay (i ⋅ projT2 (t,' o))
Acc head_inst_nostep (t,' o)
    all: apply it_eq_step in i0; cbn in i0; dependent elimination i0.
Qed.

Final theorem

We have finished instanciating our generic OGS construction on the System D calculus. For good measure we give here the concrete instanciation of the soundness theorem, stating that bisimilarity of the OGS strategies substitution equivalence.

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.

Finally it does not cost much to recover the more standard CIU equivalence, which we derive here for the case of terms (not co-terms).

Definition c_of_t {Γ : neg_ctx} {A : pre_ty pos} (t : term Γ `+A)
           : state_n (Γ ▶ₛ {| sub_elt := `-A ; sub_prf := stt |}) :=
  Cut _ (t_shift1 _ t) (Whn (Var Ctx.top)) .
Notation "'name⁺'" := c_of_t.

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

Lemma sub_csk {Γ Δ : neg_ctx} {A : pre_ty pos} (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 pos
t: term Γ `+ A
s: Γ =[ val ]> Δ
k: term Δ `- A
Cut pos (t `ₜ⊛ s) k = name⁺ t ₜ⊛ a_of_sk s k
Proof.Γ, Δ: neg_ctx
A: pre_ty pos
t: term Γ `+ A
s: Γ =[ val ]> Δ
k: term Δ `- A
Cut pos (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 : pre_ty pos} : 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 pos
x, y: term Γ `+ A
name⁺ x ≈⟦ogs Δ ⟧≈ name⁺ y -> x ≈⟦ciu Δ ⟧⁺≈ y
  intros H σ k; rewrite 2 sub_csk.Δ, Γ: neg_ctx
A: pre_ty pos
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.