Theorem: FirstOrder.Language.BoundedFormula.realize_liftAt
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [liftAt]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ (liftAt n' m φ).Realize v xs ↔ φ.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) φ).Realize v xs ↔
    φ.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

tactic: induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) φ).Realize v xs ↔
    φ.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) falsum).Realize v xs ↔
    falsum.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (equal t₁✝ t₂✝)).Realize v xs ↔
    (equal t₁✝ t₂✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ l✝ : ℕ
R✝ : L.Relations l✝
ts✝ : Fin l✝ → L.Term (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (rel R✝ ts✝)).Realize v xs ↔
    (rel R✝ ts✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f₁✝).Realize v xs ↔
        f₁✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
ih2 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f₂✝).Realize v xs ↔
        f₂✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (f₁✝ ⟹ f₂✝)).Realize v xs ↔
    (f₁✝ ⟹ f₂✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (∀'f✝)).Realize v xs ↔
    (∀'f✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

tactic: simp [mapTermRel, Realize]
state_before: case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) falsum).Realize v xs ↔
    falsum.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: no goals

tactic: simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
state_before: case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (equal t₁✝ t₂✝)).Realize v xs ↔
    (equal t₁✝ t₂✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: no goals

tactic: simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
state_before: case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ l✝ : ℕ
R✝ : L.Relations l✝
ts✝ : Fin l✝ → L.Term (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (rel R✝ ts✝)).Realize v xs ↔
    (rel R✝ ts✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: no goals

tactic: simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
state_before: case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f₁✝).Realize v xs ↔
        f₁✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
ih2 :
  ∀ {xs : Fin (n✝ + n') → M},
    m + n' ≤ n✝ + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f₂✝).Realize v xs ↔
        f₂✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (f₁✝ ⟹ f₂✝)).Realize v xs ↔
    (f₁✝ ⟹ f₂✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: no goals

tactic: have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
state_before: case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (∀'f✝)).Realize v xs ↔
    (∀'f✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (∀'f✝)).Realize v xs ↔
    (∀'f✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')

tactic: simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
state_before: case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) (∀'f✝)).Realize v xs ↔
    (∀'f✝).Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')
state_after: case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (∀ (x : M), f✝.Realize v ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')) ↔
    ∀ (x : M), f✝.Realize v (snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x)

tactic: refine forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases ?_ fun i => ?_)))
state_before: case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (∀ (x : M), f✝.Realize v ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n')) ↔
    ∀ (x : M), f✝.Realize v (snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x)
state_after: case all.refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') (last k) =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x (last k)

case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') i.castSucc =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x i.castSucc

tactic: rw [add_assoc, add_comm 1 n', ← add_assoc]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ k + 1 + n' = k + n' + 1
state_after: no goals

tactic: simp only [Function.comp_apply, val_last, snoc_last]
state_before: case all.refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') (last k) =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x (last k)
state_after: case all.refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ snoc xs x (Fin.cast h (if k < m then castAdd n' (last k) else (last k).addNat n')) = x

tactic: by_cases h : k < m
state_before: case all.refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
⊢ snoc xs x (Fin.cast h (if k < m then castAdd n' (last k) else (last k).addNat n')) = x
state_after: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (Fin.cast h✝ (if k < m then castAdd n' (last k) else (last k).addNat n')) = x

case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (Fin.cast h✝ (if k < m then castAdd n' (last k) else (last k).addNat n')) = x

tactic: rw [if_pos h]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (Fin.cast h✝ (if k < m then castAdd n' (last k) else (last k).addNat n')) = x
state_after: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (Fin.cast h✝ (castAdd n' (last k))) = x

tactic: refine (congr rfl (ext ?_)).trans (snoc_last _ _)
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ snoc xs x (Fin.cast h✝ (castAdd n' (last k))) = x
state_after: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ ↑(Fin.cast h✝ (castAdd n' (last k))) = ↑(last (k + n'))

tactic: simp only [coe_cast, coe_castAdd, val_last, self_eq_add_right]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ ↑(Fin.cast h✝ (castAdd n' (last k))) = ↑(last (k + n'))
state_after: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ n' = 0

tactic: refine le_antisymm
  (le_of_add_le_add_left ((hmn.trans (Nat.succ_le_of_lt h)).trans ?_)) n'.zero_le
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ n' = 0
state_after: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ m ≤ m + 0

tactic: rw [add_zero]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : k < m
⊢ m ≤ m + 0
state_after: no goals

tactic: rw [if_neg h]
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (Fin.cast h✝ (if k < m then castAdd n' (last k) else (last k).addNat n')) = x
state_after: case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (Fin.cast h✝ ((last k).addNat n')) = x

tactic: refine (congr rfl (ext ?_)).trans (snoc_last _ _)
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ snoc xs x (Fin.cast h✝ ((last k).addNat n')) = x
state_after: case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ ↑(Fin.cast h✝ ((last k).addNat n')) = ↑(last (k + n'))

tactic: simp
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h✝ : k + 1 + n' = k + n' + 1
x : M
h : ¬k < m
⊢ ↑(Fin.cast h✝ ((last k).addNat n')) = ↑(last (k + n'))
state_after: no goals

tactic: simp only [Function.comp_apply, Fin.snoc_castSucc]
state_before: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ((snoc xs x ∘ Fin.cast h) ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') i.castSucc =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n') x i.castSucc
state_after: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ snoc xs x (Fin.cast h (if ↑i.castSucc < m then castAdd n' i.castSucc else i.castSucc.addNat n')) =
    xs (if ↑i < m then castAdd n' i else i.addNat n')

tactic: refine (congr rfl (ext ?_)).trans (snoc_castSucc _ _ _)
state_before: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ snoc xs x (Fin.cast h (if ↑i.castSucc < m then castAdd n' i.castSucc else i.castSucc.addNat n')) =
    xs (if ↑i < m then castAdd n' i else i.addNat n')
state_after: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(Fin.cast h (if ↑i.castSucc < m then castAdd n' i.castSucc else i.castSucc.addNat n')) =
    ↑(if ↑i < m then castAdd n' i else i.addNat n').castSucc

tactic: simp only [coe_castSucc, coe_cast]
state_before: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(Fin.cast h (if ↑i.castSucc < m then castAdd n' i.castSucc else i.castSucc.addNat n')) =
    ↑(if ↑i < m then castAdd n' i else i.addNat n').castSucc
state_after: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(if ↑i < m then castAdd n' i.castSucc else i.castSucc.addNat n') = ↑(if ↑i < m then castAdd n' i else i.addNat n')

tactic: split_ifs <;> simp
state_before: case all.refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
k : ℕ
f✝ : L.BoundedFormula α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      ((mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE ⋯) f✝).Realize v xs ↔
        f✝.Realize v (xs ∘ fun i => if ↑i < m then castAdd n' i else i.addNat n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
x : M
i : Fin k
⊢ ↑(if ↑i < m then castAdd n' i.castSucc else i.castSucc.addNat n') = ↑(if ↑i < m then castAdd n' i else i.addNat n')
state_after: no goals