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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + n') → M
hmn : m + n' ≤ n + 1
⊢ Realize (liftAt n' m φ) v xs ↔ Realize φ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

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

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

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1))
        (equal t₁✝ t₂✝))
      v xs ↔
    Realize (equal t₁✝ t₂✝) v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin (n✝ + n') → M
hmn : m + n' ≤ n✝ + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1))
        (rel R✝ ts✝))
      v xs ↔
    Realize (rel R✝ ts✝) v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

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

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) (∀'f✝))
      v xs ↔
    Realize (∀'f✝) v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ Realize
      (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) (∀'f✝))
      v xs ↔
    Realize (∀'f✝) v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
h : k + 1 + n' = k + n' + 1
⊢ (∀ (x : M),
      Realize f✝ v ((snoc xs x ∘ ↑(Fin.cast h)) ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)) ↔
    ∀ (x : M), Realize f✝ v (snoc (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i) x)

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

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(addNat n') i) (last k) =
    snoc (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i) x (last k)

tactic: by_cases k < m
state_before: case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(addNat n') (last k))) = x

tactic: rw [if_pos h]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(addNat 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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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: simp only [coe_orderIso_apply, coe_castAdd, val_last, self_eq_add_right]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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: 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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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: rw [add_zero]
state_before: case pos
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 [if_neg h]
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(addNat n') (last k))) = x

tactic: refine' (congr rfl (ext _)).trans (snoc_last _ _)
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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✝) (↑(addNat n') (last k))) = x

tactic: simp
state_before: case neg
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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✝) (↑(addNat n') (last k))) = ↑(last (k + n'))

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.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(addNat n') i) (↑castSucc i) =
    snoc (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i) x (↑castSucc i)

tactic: refine' (congr rfl (ext _)).trans (snoc_castSucc _ _ _)
state_before: case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(↑castSucc i) < m then ↑(castAdd n') (↑castSucc i) else ↑(addNat n') (↑castSucc i))) =
    xs (if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)

tactic: simp only [coe_castSucc, coe_orderIso_apply]
state_before: case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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 ↑(↑castSucc i) < m then ↑(castAdd n') (↑castSucc i) else ↑(addNat n') (↑castSucc i))) =
    ↑(↑castSucc (if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))

tactic: split_ifs <;> simp
state_before: case all.refine'_2
L : Language
L' : Language
M : Type w
N : Type ?u.105226
P : Type ?u.105229
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
n n' m : ℕ
v : α → M
xs✝ : Fin (n + n') → M
hmn✝ : m + n' ≤ n + 1
k : ℕ
f✝ : BoundedFormula L α (k + 1)
ih3 :
  ∀ {xs : Fin (k + 1 + n') → M},
    m + n' ≤ k + 1 + 1 →
      (Realize
          (mapTermRel (fun k t => Term.liftAt n' m t) (fun x => id) (fun x => castLE (_ : x + 1 + n' ≤ x + n' + 1)) f✝)
          v xs ↔
        Realize f✝ v (xs ∘ fun i => if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i))
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') (↑castSucc i) else ↑(addNat n') (↑castSucc i)) =
    ↑(if ↑i < m then ↑(castAdd n') i else ↑(addNat n') i)