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

tactic: induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
φ : BoundedFormula L α n
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) φ) v' xs ↔
    Realize φ (v xs) (xs ∘ ↑(natAdd k))

tactic: rfl
state_before: case falsum
L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) falsum) v' xs ↔
    Realize falsum (v xs) (xs ∘ ↑(natAdd k))

tactic: simp [mapTermRel, Realize, h1]
state_before: case equal
L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (equal t₁✝ t₂✝)) v' xs ↔
    Realize (equal t₁✝ t₂✝) (v xs) (xs ∘ ↑(natAdd k))

tactic: simp [mapTermRel, Realize, h1, h2]
state_before: case rel
L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (rel R✝ ts✝)) v' xs ↔
    Realize (rel R✝ ts✝) (v xs) (xs ∘ ↑(natAdd k))

tactic: simp [mapTermRel, Realize, ih1, ih2]
state_before: case imp
L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 :
  ∀ (xs : Fin (k + n✝) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f₁✝) v' xs ↔
      Realize f₁✝ (v xs) (xs ∘ ↑(natAdd k))
ih2 :
  ∀ (xs : Fin (k + n✝) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f₂✝) v' xs ↔
      Realize f₂✝ (v xs) (xs ∘ ↑(natAdd k))
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (f₁✝ ⟹ f₂✝)) v' xs ↔
    Realize (f₁✝ ⟹ f₂✝) (v xs) (xs ∘ ↑(natAdd k))

tactic: simp [mapTermRel, Realize, ih, hv]
state_before: case all
L : Language
L' : Language
M : Type w
N : Type ?u.78808
P : Type ?u.78811
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
inst✝ : Structure L' M
k : ℕ
ft : (n : ℕ) → Term L (α ⊕ Fin n) → Term L' (β ⊕ Fin (k + n))
fr : (n : ℕ) → Relations L n → Relations L' n
n : ℕ
v : {n : ℕ} → (Fin (k + n) → M) → α → M
v' : β → M
xs✝ : Fin (k + n) → M
h1 :
  ∀ (n : ℕ) (t : Term L (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    realize (Sum.elim v' xs') (ft n t) = realize (Sum.elim (v xs') (xs' ∘ ↑(natAdd k))) t
h2 : ∀ (n : ℕ) (R : Relations L n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x
hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (snoc xs x) = v xs
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih :
  ∀ (xs : Fin (k + (n✝ + 1)) → M),
    Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) f✝) v' xs ↔
      Realize f✝ (v xs) (xs ∘ ↑(natAdd k))
xs : Fin (k + n✝) → M
⊢ Realize (mapTermRel ft fr (fun n => castLE (_ : k + (n + 1) ≤ k + n + 1)) (∀'f✝)) v' xs ↔
    Realize (∀'f✝) (v xs) (xs ∘ ↑(natAdd k))