Theorem: Set.definable_iff_exists_formula_sum
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [Definable, Equiv.exists_congr_left (BoundedFormula.constantsVarsEquiv)]
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ A.Definable L s ↔ ∃ φ, s = {v | φ.Realize (Sum.elim Subtype.val v)}
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ (∃ b, s = setOf (Formula.Realize (BoundedFormula.constantsVarsEquiv.symm b))) ↔
    ∃ φ, s = {v | φ.Realize (Sum.elim Subtype.val v)}

tactic: ext
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
⊢ setOf (Formula.Realize (BoundedFormula.constantsVarsEquiv.symm φ)) = {v | Formula.Realize φ (Sum.elim Subtype.val v)}
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ x✝ ∈ setOf (Formula.Realize (BoundedFormula.constantsVarsEquiv.symm φ)) ↔
    x✝ ∈ {v | Formula.Realize φ (Sum.elim Subtype.val v)}

tactic: simp only [Formula.Realize, BoundedFormula.constantsVarsEquiv, constantsOn, mk₂_Relations,
  BoundedFormula.mapTermRelEquiv_symm_apply, mem_setOf_eq]
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ x✝ ∈ setOf (Formula.Realize (BoundedFormula.constantsVarsEquiv.symm φ)) ↔
    x✝ ∈ {v | Formula.Realize φ (Sum.elim Subtype.val v)}
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ (BoundedFormula.mapTermRel (fun n => ⇑Term.constantsVarsEquivLeft.symm)
          (fun n => ⇑(Equiv.sumEmpty (L.Relations n) (Sequence₂ PEmpty.{1} PEmpty.{1} PEmpty.{1} n)).symm) (fun x => id)
          φ).Realize
      x✝ default ↔
    φ.Realize (Sum.elim Subtype.val x✝) default

tactic: refine BoundedFormula.realize_mapTermRel_id ?_ (fun _ _ _ => rfl)
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ (BoundedFormula.mapTermRel (fun n => ⇑Term.constantsVarsEquivLeft.symm)
          (fun n => ⇑(Equiv.sumEmpty (L.Relations n) (Sequence₂ PEmpty.{1} PEmpty.{1} PEmpty.{1} n)).symm) (fun x => id)
          φ).Realize
      x✝ default ↔
    φ.Realize (Sum.elim Subtype.val x✝) default
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ ∀ (n : ℕ) (t : L.Term ((↑A ⊕ α) ⊕ Fin n)) (xs : Fin n → M),
    Term.realize (Sum.elim x✝ xs) (Term.constantsVarsEquivLeft.symm t) =
      Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs) t

tactic: intros
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
⊢ ∀ (n : ℕ) (t : L.Term ((↑A ⊕ α) ⊕ Fin n)) (xs : Fin n → M),
    Term.realize (Sum.elim x✝ xs) (Term.constantsVarsEquivLeft.symm t) =
      Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs) t
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Term.realize (Sum.elim x✝ xs✝) (Term.constantsVarsEquivLeft.symm t✝) =
    Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs✝) t✝

tactic: simp only [Term.constantsVarsEquivLeft_symm_apply, Term.realize_varsToConstants,
  coe_con, Term.realize_relabel]
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Term.realize (Sum.elim x✝ xs✝) (Term.constantsVarsEquivLeft.symm t✝) =
    Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs✝) t✝
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Term.realize (Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝))) t✝ =
    Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs✝) t✝

tactic: congr
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Term.realize (Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝))) t✝ =
    Term.realize (Sum.elim (Sum.elim Subtype.val x✝) xs✝) t✝
state_after: case h.e_v
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝)) = Sum.elim (Sum.elim Subtype.val x✝) xs✝

tactic: ext a
state_before: case h.e_v
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
⊢ Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝)) = Sum.elim (Sum.elim Subtype.val x✝) xs✝
state_after: case h.e_v.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
a : (↑A ⊕ α) ⊕ Fin n✝
⊢ (Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝))) a =
    Sum.elim (Sum.elim Subtype.val x✝) xs✝ a

tactic: rcases a with (_ | _) | _ <;> rfl
state_before: case h.e_v.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ : L.BoundedFormula (↑A ⊕ α) 0
x✝ : α → M
n✝ : ℕ
t✝ : L.Term ((↑A ⊕ α) ⊕ Fin n✝)
xs✝ : Fin n✝ → M
a : (↑A ⊕ α) ⊕ Fin n✝
⊢ (Sum.elim (fun a => ↑a) (Sum.elim x✝ xs✝) ∘ ⇑(Equiv.sumAssoc (↑A) α (Fin n✝))) a =
    Sum.elim (Sum.elim Subtype.val x✝) xs✝ a
state_after: no goals