Theorem: FirstOrder.Language.Term.realize_varsToConstants
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' t with ab n f ts ih
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
t : L.Term (α ⊕ β)
v : β → M
⊢ realize v t.varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) t
state_after: case var
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
ab : α ⊕ β
⊢ realize v (var ab).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var ab)

case func
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
n : ℕ
f : L.Functions n
ts : Fin n → L.Term (α ⊕ β)
ih : ∀ (a : Fin n), realize v (ts a).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (ts a)
⊢ realize v (func f ts).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (func f ts)

tactic: cases' ab with a b
state_before: case var
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
ab : α ⊕ β
⊢ realize v (var ab).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var ab)
state_after: case var.inl
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
a : α
⊢ realize v (var (Sum.inl a)).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var (Sum.inl a))

case var.inr
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
b : β
⊢ realize v (var (Sum.inr b)).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var (Sum.inr b))

tactic: simp [Language.con, realize, funMap_eq_coe_constants]
state_before: case var.inl
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
a : α
⊢ realize v (var (Sum.inl a)).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var (Sum.inl a))
state_after: no goals

tactic: simp [realize, constantMap]
state_before: case var.inr
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
b : β
⊢ realize v (var (Sum.inr b)).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (var (Sum.inr b))
state_after: no goals

tactic: simp only [realize, constantsOn, mk₂_Functions, ih]
state_before: case func
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
n : ℕ
f : L.Functions n
ts : Fin n → L.Term (α ⊕ β)
ih : ∀ (a : Fin n), realize v (ts a).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (ts a)
⊢ realize v (func f ts).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (func f ts)
state_after: case func
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
n : ℕ
f : L.Functions n
ts : Fin n → L.Term (α ⊕ β)
ih : ∀ (a : Fin n), realize v (ts a).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (ts a)
⊢ (funMap (Sum.inl f) fun i => realize (Sum.elim (fun a => ↑(L.con a)) v) (ts i)) =
    funMap f fun i => realize (Sum.elim (fun a => ↑(L.con a)) v) (ts i)

tactic: rw [withConstants_funMap_sum_inl]
state_before: case func
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
inst✝¹ : L[[α]].Structure M
inst✝ : (L.lhomWithConstants α).IsExpansionOn M
v : β → M
n : ℕ
f : L.Functions n
ts : Fin n → L.Term (α ⊕ β)
ih : ∀ (a : Fin n), realize v (ts a).varsToConstants = realize (Sum.elim (fun a => ↑(L.con a)) v) (ts a)
⊢ (funMap (Sum.inl f) fun i => realize (Sum.elim (fun a => ↑(L.con a)) v) (ts i)) =
    funMap f fun i => realize (Sum.elim (fun a => ↑(L.con a)) v) (ts i)
state_after: no goals