l3lab/ntp-mathlib huggingface dataset:
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · 

Proof state:
case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝¹ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i n'))
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 i 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))
        (f₁✝ ⟹ f₂✝))
      v xs ↔
    Realize (f₁✝ ⟹ f₂✝) v (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n')

Next tactic:
simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · 

Proof state:
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i n'))
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 i n')

Next tactic:
have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by 

Proof state:
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i n'))
xs : Fin (k + n') → M
hmn : m + n' ≤ k + 1
⊢ k + 1 + n' = k + n' + 1

Next tactic:
rw [add_assoc, add_comm 1 n', ← add_assoc]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    

Proof state:
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i n'))
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 i n')

Next tactic:
simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    

Proof state:
case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i n'))
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 i n')) ↔
    ∀ (x : M), Realize f✝ v (snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') x)

Next tactic:
refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · 

Proof state:
case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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 addNat i n') (last k) =
    snoc (xs ∘ fun i => if ↑i < m then castAdd n' i else addNat i n') x (last k)

Next tactic:
simp only [Function.comp_apply, val_last, snoc_last]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      

Proof state:
case all.refine'_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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 addNat (last k) n')) = x

Next tactic:
by_cases h : k < m
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · 

Proof state:
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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 addNat (last k) n')) = x

Next tactic:
rw [if_pos h]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · rw [if_pos h]
        

Proof state:
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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

Next tactic:
refine' (congr rfl (ext _)).trans (snoc_last _ _)
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · rw [if_pos h]
        refine' (congr rfl (ext _)).trans (snoc_last _ _)
        

Proof state:
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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'))

Next tactic:
simp only [coe_cast, coe_castAdd, val_last, self_eq_add_right]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · rw [if_pos h]
        refine' (congr rfl (ext _)).trans (snoc_last _ _)
        simp only [coe_cast, coe_castAdd, val_last, self_eq_add_right]
        

Proof state:
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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

Next tactic:
refine'
          le_antisymm (le_of_add_le_add_left ((hmn.trans (Nat.succ_le_of_lt h)).trans _)) n'.zero_le
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · rw [if_pos h]
        refine' (congr rfl (ext _)).trans (snoc_last _ _)
        simp only [coe_cast, coe_castAdd, val_last, self_eq_add_right]
        refine'
          le_antisymm (le_of_add_le_add_left ((hmn.trans (Nat.succ_le_of_lt h)).trans _)) n'.zero_le
        

Proof state:
case pos
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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

Next tactic:
rw [add_zero]
theorem realize_liftAt {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 Fin.castAdd n' i else Fin.addNat i n') := by
  rw [liftAt]
  induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 k _ ih3
  · simp [mapTermRel, Realize]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp [mapTermRel, Realize, realize_rel, realize_liftAt, Sum.elim_comp_map]
  · simp only [mapTermRel, Realize, ih1 hmn, ih2 hmn]
  · have h : k + 1 + n' = k + n' + 1 := by rw [add_assoc, add_comm 1 n', ← add_assoc]
    simp only [mapTermRel, Realize, realize_castLE_of_eq h, ih3 (hmn.trans k.succ.le_succ)]
    refine' forall_congr' fun x => iff_eq_eq.mpr (congr rfl (funext (Fin.lastCases _ fun i => _)))
    · simp only [Function.comp_apply, val_last, snoc_last]
      by_cases h : k < m
      · rw [if_pos h]
        refine' (congr rfl (ext _)).trans (snoc_last _ _)
        simp only [coe_cast, coe_castAdd, val_last, self_eq_add_right]
        refine'
          le_antisymm (le_of_add_le_add_left ((hmn.trans (Nat.succ_le_of_lt h)).trans _)) n'.zero_le
        rw [add_zero]
      · 

Proof state:
case neg
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n n' m : ℕ
v : α → M
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 i 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 addNat (last k) n')) = x

Next tactic:
rw [if_neg h]