Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux (FOL/NV/Sub/Var/All/Ind/Sub.lean)

State before:
D : Type
I : Interpretation D
V V' : VarAssignment D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
h1 : IsSubAux σ binders F F'
h2 : ∀ v ∈ binders, V v = V' (σ v)
h3 : ∀ (v : VarName), σ v ∉ binders → V v = V' (σ v)
h4 : ∀ v ∈ binders, v = σ v
⊢ Holds D I V E F ↔ Holds D I V' E F'
Tactic:
induction h1 generalizing V V'
State after:
case pred_const_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
X✝ : PredName
xs✝ : List VarName
a✝ : ∀ v ∈ xs✝, v ∉ binders✝ → σ✝ v ∉ binders✝
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (pred_const_ X✝ xs✝) ↔ Holds D I V' E (pred_const_ X✝ (List.map σ✝ xs✝))

case pred_var_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
X✝ : PredName
xs✝ : List VarName
a✝ : ∀ v ∈ xs✝, v ∉ binders✝ → σ✝ v ∉ binders✝
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (pred_var_ X✝ xs✝) ↔ Holds D I V' E (pred_var_ X✝ (List.map σ✝ xs✝))

case eq_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
x✝ y✝ : VarName
a✝ : ∀ (v : VarName), v = x✝ ∨ v = y✝ → v ∉ binders✝ → σ✝ v ∉ binders✝
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (eq_ x✝ y✝) ↔ Holds D I V' E (eq_ (σ✝ x✝) (σ✝ y✝))

case true_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E true_ ↔ Holds D I V' E true_

case false_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E false_ ↔ Holds D I V' E false_

case not_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
phi✝ phi'✝ : Formula
a✝ : IsSubAux σ✝ binders✝ phi✝ phi'✝
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E phi✝.not_ ↔ Holds D I V' E phi'✝.not_

case imp_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
phi✝ psi✝ phi'✝ psi'✝ : Formula
a✝¹ : IsSubAux σ✝ binders✝ phi✝ phi'✝
a✝ : IsSubAux σ✝ binders✝ psi✝ psi'✝
a_ih✝¹ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E psi✝ ↔ Holds D I V' E psi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (phi✝.imp_ psi✝) ↔ Holds D I V' E (phi'✝.imp_ psi'✝)

case and_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
phi✝ psi✝ phi'✝ psi'✝ : Formula
a✝¹ : IsSubAux σ✝ binders✝ phi✝ phi'✝
a✝ : IsSubAux σ✝ binders✝ psi✝ psi'✝
a_ih✝¹ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E psi✝ ↔ Holds D I V' E psi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (phi✝.and_ psi✝) ↔ Holds D I V' E (phi'✝.and_ psi'✝)

case or_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
phi✝ psi✝ phi'✝ psi'✝ : Formula
a✝¹ : IsSubAux σ✝ binders✝ phi✝ phi'✝
a✝ : IsSubAux σ✝ binders✝ psi✝ psi'✝
a_ih✝¹ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E psi✝ ↔ Holds D I V' E psi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (phi✝.or_ psi✝) ↔ Holds D I V' E (phi'✝.or_ psi'✝)

case iff_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
phi✝ psi✝ phi'✝ psi'✝ : Formula
a✝¹ : IsSubAux σ✝ binders✝ phi✝ phi'✝
a✝ : IsSubAux σ✝ binders✝ psi✝ psi'✝
a_ih✝¹ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝, V v = V' (σ✝ v)) →
      (∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)) →
        (∀ v ∈ binders✝, v = σ✝ v) → (Holds D I V E psi✝ ↔ Holds D I V' E psi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (phi✝.iff_ psi✝) ↔ Holds D I V' E (phi'✝.iff_ psi'✝)

case forall_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
x✝ : VarName
phi✝ phi'✝ : Formula
a✝ : IsSubAux (Function.updateITE σ✝ x✝ x✝) (binders✝ ∪ {x✝}) phi✝ phi'✝
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝ ∪ {x✝}, V v = V' (Function.updateITE σ✝ x✝ x✝ v)) →
      (∀ (v : VarName), Function.updateITE σ✝ x✝ x✝ v ∉ binders✝ ∪ {x✝} → V v = V' (Function.updateITE σ✝ x✝ x✝ v)) →
        (∀ v ∈ binders✝ ∪ {x✝}, v = Function.updateITE σ✝ x✝ x✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (forall_ x✝ phi✝) ↔ Holds D I V' E (forall_ x✝ phi'✝)

case exists_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
x✝ : VarName
phi✝ phi'✝ : Formula
a✝ : IsSubAux (Function.updateITE σ✝ x✝ x✝) (binders✝ ∪ {x✝}) phi✝ phi'✝
a_ih✝ :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders✝ ∪ {x✝}, V v = V' (Function.updateITE σ✝ x✝ x✝ v)) →
      (∀ (v : VarName), Function.updateITE σ✝ x✝ x✝ v ∉ binders✝ ∪ {x✝} → V v = V' (Function.updateITE σ✝ x✝ x✝ v)) →
        (∀ v ∈ binders✝ ∪ {x✝}, v = Function.updateITE σ✝ x✝ x✝ v) → (Holds D I V E phi✝ ↔ Holds D I V' E phi'✝)
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (exists_ x✝ phi✝) ↔ Holds D I V' E (exists_ x✝ phi'✝)

case def_
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
X✝ : DefName
xs✝ : List VarName
a✝ : ∀ v ∈ xs✝, v ∉ binders✝ → σ✝ v ∉ binders✝
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E (def_ X✝ xs✝) ↔ Holds D I V' E (def_ X✝ (List.map σ✝ xs✝))

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E false_ ↔ Holds D I V' E false_
Tactic:
case true_ | false_ =>
  simp only [Holds]
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi.not_ ↔ Holds D I V' E phi'.not_
Tactic:
case not_ σ' binders' phi phi' _ ih_2 =>
  simp only [Holds]
  congr! 1
  exact ih_2 V V' h2 h3 h4
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (pred_var_ X' xs') ↔ Holds D I V' E (pred_var_ X' (List.map σ' xs'))
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ I.pred_var_ X' (List.map V xs') ↔ I.pred_var_ X' (List.map V' (List.map σ' xs'))

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ I.pred_var_ X' (List.map V xs') ↔ I.pred_var_ X' (List.map V' (List.map σ' xs'))
Tactic:
simp
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ I.pred_var_ X' (List.map V xs') ↔ I.pred_var_ X' (List.map (V' ∘ σ') xs')

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ I.pred_var_ X' (List.map V xs') ↔ I.pred_var_ X' (List.map (V' ∘ σ') xs')
Tactic:
congr! 1
State after:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ List.map V xs' = List.map (V' ∘ σ') xs'

State before:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ List.map V xs' = List.map (V' ∘ σ') xs'
Tactic:
simp only [List.map_eq_map_iff]
State after:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x

State before:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x
Tactic:
intro x a1
State after:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
⊢ V x = (V' ∘ σ') x

State before:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
⊢ V x = (V' ∘ σ') x
Tactic:
simp
State after:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
⊢ V x = V' (σ' x)

State before:
case a.h.e'_4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
⊢ V x = V' (σ' x)
Tactic:
by_cases c1 : x ∈ binders'
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∈ binders'
⊢ V x = V' (σ' x)

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∉ binders'
⊢ V x = V' (σ' x)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∈ binders'
⊢ V x = V' (σ' x)
Tactic:
exact h2 x c1
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∉ binders'
⊢ V x = V' (σ' x)
Tactic:
apply h3
State after:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∉ binders'
⊢ σ' x ∉ binders'

State before:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : PredName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
x : VarName
a1 : x ∈ xs'
c1 : x ∉ binders'
⊢ σ' x ∉ binders'
Tactic:
exact ih_1 x a1 c1
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (eq_ x y) ↔ Holds D I V' E (eq_ (σ' x) (σ' y))
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V x = V y ↔ V' (σ' x) = V' (σ' y)

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V x = V y ↔ V' (σ' x) = V' (σ' y)
Tactic:
congr! 1
State after:
case a.h.e'_2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V x = V' (σ' x)

case a.h.e'_3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V y = V' (σ' y)

State before:
case a.h.e'_2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V x = V' (σ' x)
Tactic:
by_cases c1 : x ∈ binders'
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∈ binders'
⊢ V x = V' (σ' x)

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ V x = V' (σ' x)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∈ binders'
⊢ V x = V' (σ' x)
Tactic:
exact h2 x c1
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ V x = V' (σ' x)
Tactic:
apply h3
State after:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ σ' x ∉ binders'

State before:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ σ' x ∉ binders'
Tactic:
apply ih_1
State after:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ x = x ∨ x = y

case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ x ∉ binders'

State before:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ x = x ∨ x = y
Tactic:
simp
State after:
no goals

State before:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : x ∉ binders'
⊢ x ∉ binders'
Tactic:
exact c1
State after:
no goals

State before:
case a.h.e'_3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ V y = V' (σ' y)
Tactic:
by_cases c1 : y ∈ binders'
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∈ binders'
⊢ V y = V' (σ' y)

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ V y = V' (σ' y)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∈ binders'
⊢ V y = V' (σ' y)
Tactic:
exact h2 y c1
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ V y = V' (σ' y)
Tactic:
apply h3
State after:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ σ' y ∉ binders'

State before:
case neg.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ σ' y ∉ binders'
Tactic:
apply ih_1
State after:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ y = x ∨ y = y

case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ y ∉ binders'

State before:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ y = x ∨ y = y
Tactic:
simp
State after:
no goals

State before:
case neg.a.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x y : VarName
ih_1 : ∀ (v : VarName), v = x ∨ v = y → v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
c1 : y ∉ binders'
⊢ y ∉ binders'
Tactic:
exact c1
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ✝ : VarName → VarName
binders✝ : Finset VarName
V V' : VarAssignment D
h2 : ∀ v ∈ binders✝, V v = V' (σ✝ v)
h3 : ∀ (v : VarName), σ✝ v ∉ binders✝ → V v = V' (σ✝ v)
h4 : ∀ v ∈ binders✝, v = σ✝ v
⊢ Holds D I V E false_ ↔ Holds D I V' E false_
Tactic:
simp only [Holds]
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi.not_ ↔ Holds D I V' E phi'.not_
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ ¬Holds D I V E phi ↔ ¬Holds D I V' E phi'

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ ¬Holds D I V E phi ↔ ¬Holds D I V' E phi'
Tactic:
congr! 1
State after:
case a.h.e'_1.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi ↔ Holds D I V' E phi'

State before:
case a.h.e'_1.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi phi' : Formula
a✝ : IsSubAux σ' binders' phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi ↔ Holds D I V' E phi'
Tactic:
exact ih_2 V V' h2 h3 h4
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (phi.iff_ psi) ↔ Holds D I V' E (phi'.iff_ psi')
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ (Holds D I V E phi ↔ Holds D I V E psi) ↔ (Holds D I V' E phi' ↔ Holds D I V' E psi')

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ (Holds D I V E phi ↔ Holds D I V E psi) ↔ (Holds D I V' E phi' ↔ Holds D I V' E psi')
Tactic:
congr! 1
State after:
case a.h.e'_1.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi ↔ Holds D I V' E phi'

case a.h.e'_2.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E psi ↔ Holds D I V' E psi'

State before:
case a.h.e'_1.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E phi ↔ Holds D I V' E phi'
Tactic:
apply phi_ih_2 V V' h2 h3 h4
State after:
no goals

State before:
case a.h.e'_2.a
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
phi psi phi' psi' : Formula
a✝¹ : IsSubAux σ' binders' phi phi'
a✝ : IsSubAux σ' binders' psi psi'
phi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E phi ↔ Holds D I V' E phi')
psi_ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders', V v = V' (σ' v)) →
      (∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)) →
        (∀ v ∈ binders', v = σ' v) → (Holds D I V E psi ↔ Holds D I V' E psi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E psi ↔ Holds D I V' E psi'
Tactic:
apply psi_ih_2 V V' h2 h3 h4
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ v ∈ binders' ∪ {x}, V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName), Function.updateITE σ' x x v ∉ binders' ∪ {x} → V v = V' (Function.updateITE σ' x x v)) →
        (∀ v ∈ binders' ∪ {x}, v = Function.updateITE σ' x x v) → (Holds D I V E phi ↔ Holds D I V' E phi')
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
simp at ih_2
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
have s1 : ∀ (v : VarName), ¬ v = x → v ∈ binders' → ¬ σ' v = x
State after:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
⊢ ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
⊢ ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
intro v a1 a2 contra
State after:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ False

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ False

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
apply a1
State after:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ v = x

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ v = x

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
simp only [← contra]
State after:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ v = σ' v

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
case s1
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
v : VarName
a1 : ¬v = x
a2 : v ∈ binders'
contra : σ' v = x
⊢ v = σ' v

D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
exact h4 v a2
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ Holds D I V E (exists_ x phi) ↔ Holds D I V' E (exists_ x phi')
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ (∃ d, Holds D I (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V' x d) E phi'

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ (∃ d, Holds D I (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V' x d) E phi'
Tactic:
first | apply forall_congr'| apply exists_congr
State after:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V' x a) E phi'

State before:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V' x a) E phi'
Tactic:
intro d
State after:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ Holds D I (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V' x d) E phi'

State before:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ Holds D I (Function.updateITE V x d) E phi ↔ Holds D I (Function.updateITE V' x d) E phi'
Tactic:
apply ih_2
State after:
case h.h2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName),
    v ∈ binders' ∨ v = x → Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

case h.h3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName),
    Function.updateITE σ' x x v ∉ binders' →
      ¬Function.updateITE σ' x x v = x →
        Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ (∀ (d : D), Holds D I (Function.updateITE V x d) E phi) ↔ ∀ (d : D), Holds D I (Function.updateITE V' x d) E phi'
Tactic:
apply forall_congr'
State after:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V' x a) E phi'

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ (∃ d, Holds D I (Function.updateITE V x d) E phi) ↔ ∃ d, Holds D I (Function.updateITE V' x d) E phi'
Tactic:
apply exists_congr
State after:
case h
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E phi ↔ Holds D I (Function.updateITE V' x a) E phi'

State before:
case h.h2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName),
    v ∈ binders' ∨ v = x → Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
intro v a1
State after:
case h.h2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case h.h2
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
by_cases c1 : v = x
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [Function.updateITE]
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)
Tactic:
simp only [if_pos c1]
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ d = if True then d else V' x

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ d = if True then d else V' x
Tactic:
simp
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [Function.updateITE]
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)
Tactic:
simp only [if_neg c1]
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ V v = if σ' v = x then d else V' (σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
cases a1
State after:
case neg.inl
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
h✝ : v ∈ binders'
⊢ V v = if σ' v = x then d else V' (σ' v)

case neg.inr
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
h✝ : v = x
⊢ V v = if σ' v = x then d else V' (σ' v)

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
case _ c2 =>
  simp only [s1 v c1 c2]
  simp
  exact h2 v c2
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v = x
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
case _ c2 =>
  contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
simp only [s1 v c1 c2]
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = if False then d else V' (σ' v)

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = if False then d else V' (σ' v)
Tactic:
simp
State after:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = V' (σ' v)

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ V v = V' (σ' v)
Tactic:
exact h2 v c2
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v = x
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
contradiction
State after:
no goals

State before:
case h.h3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName),
    Function.updateITE σ' x x v ∉ binders' →
      ¬Function.updateITE σ' x x v = x →
        Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
intro v a1
State after:
case h.h3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case h.h3
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
by_cases c1 : v = x
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : ¬v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [Function.updateITE]
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬(if v = x then x else σ' v) = x →
    (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬(if v = x then x else σ' v) = x →
    (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)
Tactic:
simp only [if_pos c1]
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬True → d = if True then d else V' x

State before:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : v = x
⊢ ¬True → d = if True then d else V' x
Tactic:
simp
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : Function.updateITE σ' x x v ∉ binders'
c1 : ¬v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [Function.updateITE] at a1
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : (if v = x then x else σ' v) ∉ binders'
c1 : ¬v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : (if v = x then x else σ' v) ∉ binders'
c1 : ¬v = x
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [if_neg c1] at a1
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬Function.updateITE σ' x x v = x →
    Function.updateITE V x d v = Function.updateITE V' x d (Function.updateITE σ' x x v)
Tactic:
simp only [Function.updateITE]
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬(if v = x then x else σ' v) = x →
    (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬(if v = x then x else σ' v) = x →
    (if v = x then d else V v) = if (if v = x then x else σ' v) = x then d else V' (if v = x then x else σ' v)
Tactic:
simp only [if_neg c1]
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬σ' v = x → V v = if σ' v = x then d else V' (σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
⊢ ¬σ' v = x → V v = if σ' v = x then d else V' (σ' v)
Tactic:
intro a2
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
a2 : ¬σ' v = x
⊢ V v = if σ' v = x then d else V' (σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
a2 : ¬σ' v = x
⊢ V v = if σ' v = x then d else V' (σ' v)
Tactic:
simp only [if_neg a2]
State after:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
a2 : ¬σ' v = x
⊢ V v = V' (σ' v)

State before:
case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
a1 : σ' v ∉ binders'
a2 : ¬σ' v = x
⊢ V v = V' (σ' v)
Tactic:
apply h3 v a1
State after:
no goals

State before:
case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
⊢ ∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v
Tactic:
intro v a1
State after:
case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ v = Function.updateITE σ' x x v

State before:
case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ v = Function.updateITE σ' x x v
Tactic:
simp only [Function.updateITE]
State after:
case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ v = if v = x then x else σ' v

State before:
case h.h4
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
⊢ v = if v = x then x else σ' v
Tactic:
split_ifs
State after:
case pos
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
h✝ : v = x
⊢ v = x

case neg
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
h✝ : ¬v = x
⊢ v = σ' v

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ v = x
Tactic:
case _ c1 =>
  exact c1
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ v = σ' v
Tactic:
case _ c1 =>
  cases a1
  case _ c2 =>
    exact h4 v c2
  case _ c2 =>
    contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : v = x
⊢ v = x
Tactic:
exact c1
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
a1 : v ∈ binders' ∨ v = x
c1 : ¬v = x
⊢ v = σ' v
Tactic:
cases a1
State after:
case inl
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
h✝ : v ∈ binders'
⊢ v = σ' v

case inr
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
h✝ : v = x
⊢ v = σ' v

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ v = σ' v
Tactic:
case _ c2 =>
  exact h4 v c2
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v = x
⊢ v = σ' v
Tactic:
case _ c2 =>
  contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v ∈ binders'
⊢ v = σ' v
Tactic:
exact h4 v c2
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v = x
⊢ v = σ' v
Tactic:
contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (def_ X' xs') ↔ Holds D I V' E (def_ X' (List.map σ' xs'))
Tactic:
induction E
State after:
case nil
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))

case cons
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
head✝ : Definition
tail✝ : List Definition
tail_ih✝ : Holds D I V tail✝ (def_ X' xs') ↔ Holds D I V' tail✝ (def_ X' (List.map σ' xs'))
⊢ Holds D I V (head✝ :: tail✝) (def_ X' xs') ↔ Holds D I V' (head✝ :: tail✝) (def_ X' (List.map σ' xs'))

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))
Tactic:
case nil =>
  simp only [Holds]
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))
Tactic:
simp only [Holds]
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
⊢ Holds D I V (hd :: tl) (def_ X' xs') ↔ Holds D I V' (hd :: tl) (def_ X' (List.map σ' xs'))
Tactic:
simp only [Holds]
State after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
⊢ (if X' = hd.name ∧ xs'.length = hd.args.length then
      Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q
    else Holds D I V tl (def_ X' xs')) ↔
    if X' = hd.name ∧ (List.map σ' xs').length = hd.args.length then
      Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
    else Holds D I V' tl (def_ X' (List.map σ' xs'))

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
⊢ (if X' = hd.name ∧ xs'.length = hd.args.length then
      Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q
    else Holds D I V tl (def_ X' xs')) ↔
    if X' = hd.name ∧ (List.map σ' xs').length = hd.args.length then
      Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
    else Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
split_ifs
State after:
case pos
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
h✝¹ : X' = hd.name ∧ xs'.length = hd.args.length
h✝ : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q

case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
h✝¹ : X' = hd.name ∧ xs'.length = hd.args.length
h✝ : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))

case pos
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
h✝¹ : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
h✝ : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q

case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
h✝¹ : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
h✝ : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
case _ c1 c2 =>
  simp only [List.length_map] at c2
  contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
case _ c1 c2 =>
  simp at c2
  contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
case _ c1 c2 =>
  exact ih
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
simp
State after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs')) tl hd.q

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs')) tl hd.q
Tactic:
apply Holds_coincide_Var
State after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ ∀ (v : VarName),
    isFreeIn v hd.q →
      Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ ∀ (v : VarName),
    isFreeIn v hd.q →
      Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
intro v a1
State after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
have s1 : List.map V xs' = List.map (V' ∘ σ') xs'
State after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ List.map V xs' = List.map (V' ∘ σ') xs'

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ List.map V xs' = List.map (V' ∘ σ') xs'

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
simp only [List.map_eq_map_iff]
State after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
intro x a2
State after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
⊢ V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
⊢ V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
by_cases c3 : x ∈ binders'
State after:
case pos
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∈ binders'
⊢ V x = (V' ∘ σ') x

case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∉ binders'
⊢ V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
simp only [s1]
State after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map (V' ∘ σ') xs') v =
    Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v

State before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map (V' ∘ σ') xs') v =
    Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
apply Function.updateListITE_mem_eq_len
State after:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
simp only [isFreeIn_iff_mem_freeVarSet] at a1
State after:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
obtain s2 := hd.h1 a1
State after:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
s2 : v ∈ hd.args.toFinset
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
s2 : v ∈ hd.args.toFinset
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
simp at s2
State after:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
s2 : v ∈ hd.args
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
a1 : v ∈ hd.q.freeVarSet
s2 : v ∈ hd.args
⊢ v ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
exact s2
State after:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
simp at c2
State after:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length

State before:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ hd.args.length = (List.map (V' ∘ σ') xs').length
Tactic:
simp
State after:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ hd.args.length = xs'.length

State before:
case h1.h2
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ hd.args.length = xs'.length
Tactic:
tauto
State after:
no goals

State before:
case pos
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∈ binders'
⊢ V x = (V' ∘ σ') x
Tactic:
exact h2 x c3
State after:
no goals

State before:
case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∉ binders'
⊢ V x = (V' ∘ σ') x
Tactic:
apply h3 x
State after:
case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∉ binders'
⊢ σ' x ∉ binders'

State before:
case neg
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
c3 : x ∉ binders'
⊢ σ' x ∉ binders'
Tactic:
apply ih_1 x a2 c3
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
simp only [List.length_map] at c2
State after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
simp at c2
State after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : X' = hd.name ∧ xs'.length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
contradiction
State after:
no goals

State before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
exact ih
State after:
no goals