ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FirstOrder.Language.BoundedFormula.realize_all
@[simp]
theorem realize_all : (all θ).Realize v xs ↔ ∀ a : M, θ.Realize v (Fin.snoc xs a) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {l : ℕ} {θ : L.BoundedFormula α l.succ} {v : α → M} {xs : Fin l → M}
Goal: θ.all.Realize v xs ↔ ∀ (a : M), θ.Realize v (Fin.snoc xs a)
-- FirstOrder.Language.BoundedFormula.realize_ex
@[simp]
theorem realize_ex : θ.ex.Realize v xs ↔ ∃ a : M, θ.Realize v (Fin.snoc xs a) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {l : ℕ} {θ : L.BoundedFormula α l.succ} {v : α → M} {xs : Fin l → M}
Goal: θ.ex.Realize v xs ↔ ∃ a, θ.Realize v (Fin.snoc xs a)
-- FirstOrder.Language.BoundedFormula.realize_iff
@[simp]
theorem realize_iff : (φ.iff ψ).Realize v xs ↔ (φ.Realize v xs ↔ ψ.Realize v xs) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l} {v : α → M} {xs : Fin l → M}
Goal: (φ.iff ψ).Realize v xs ↔ (φ.Realize v xs ↔ ψ.Realize v xs)
-- FirstOrder.Language.BoundedFormula.realize_castLE_of_eq
theorem realize_castLE_of_eq {m n : ℕ} (h : m = n) {h' : m ≤ n} {φ : L.BoundedFormula α m}
    {v : α → M} {xs : Fin n → M} : (φ.castLE h').Realize v xs ↔ φ.Realize v (xs ∘ cast h) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {m n : ℕ} (h : m = n) {h' : m ≤ n} {φ : L.BoundedFormula α m} {v : α → M} {xs : Fin n → M}
Goal: (FirstOrder.Language.BoundedFormula.castLE h' φ).Realize v xs ↔ φ.Realize v (xs ∘ Fin.cast h)
-- FirstOrder.Language.BoundedFormula.realize_mapTermRel_id
theorem realize_mapTermRel_id [L'.Structure M]
    {ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin n))}
    {fr : ∀ n, L.Relations n → L'.Relations n} {n} {φ : L.BoundedFormula α n} {v : α → M}
    {v' : β → M} {xs : Fin n → M}
    (h1 :
      ∀ (n) (t : L.Term (α ⊕ (Fin n))) (xs : Fin n → M),
        (ft n t).realize (Sum.elim v' xs) = t.realize (Sum.elim v xs))
    (h2 : ∀ (n) (R : L.Relations n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x) :
    (φ.mapTermRel ft fr fun _ => id).Realize v' xs ↔ φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} [L'.Structure M] {ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin n)} {fr : (n : ℕ) → L.Relations n → L'.Relations n} {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {v' : β → M} {xs : Fin n → M} (h1 :
  ∀ (n : ℕ) (t : L.Term (α ⊕ Fin n)) (xs : Fin n → M),
    FirstOrder.Language.Term.realize (Sum.elim v' xs) (ft n t) = FirstOrder.Language.Term.realize (Sum.elim v xs) t) (h2 :
  ∀ (n : ℕ) (R : L.Relations n) (x : Fin n → M),
    FirstOrder.Language.Structure.RelMap (fr n R) x = FirstOrder.Language.Structure.RelMap R x)
Goal: (FirstOrder.Language.BoundedFormula.mapTermRel ft fr (fun x => id) φ).Realize v' xs ↔ φ.Realize v xs
-- FirstOrder.Language.BoundedFormula.realize_mapTermRel_add_castLe
theorem realize_mapTermRel_add_castLe [L'.Structure M] {k : ℕ}
    {ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin (k + n)))}
    {fr : ∀ n, L.Relations n → L'.Relations n} {n} {φ : L.BoundedFormula α n}
    (v : ∀ {n}, (Fin (k + n) → M) → α → M) {v' : β → M} (xs : Fin (k + n) → M)
    (h1 :
      ∀ (n) (t : L.Term (α ⊕ (Fin n))) (xs' : Fin (k + n) → M),
        (ft n t).realize (Sum.elim v' xs') = t.realize (Sum.elim (v xs') (xs' ∘ Fin.natAdd _)))
    (h2 : ∀ (n) (R : L.Relations n) (x : Fin n → M), RelMap (fr n R) x = RelMap R x)
    (hv : ∀ (n) (xs : Fin (k + n) → M) (x : M), @v (n + 1) (snoc xs x : Fin _ → M) = v xs) :
    (φ.mapTermRel ft fr fun n => castLE (add_assoc _ _ _).symm.le).Realize v' xs ↔
      φ.Realize (v xs) (xs ∘ Fin.natAdd _) 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} [L'.Structure M] {k : ℕ} {ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin (k + n))} {fr : (n : ℕ) → L.Relations n → L'.Relations n} {n : ℕ} {φ : L.BoundedFormula α n} (v : {n : ℕ} → (Fin (k + n) → M) → α → M) {v' : β → M} (xs : Fin (k + n) → M) (h1 :
  ∀ (n : ℕ) (t : L.Term (α ⊕ Fin n)) (xs' : Fin (k + n) → M),
    FirstOrder.Language.Term.realize (Sum.elim v' xs') (ft n t) =
      FirstOrder.Language.Term.realize (Sum.elim (v xs') (xs' ∘ Fin.natAdd k)) t) (h2 :
  ∀ (n : ℕ) (R : L.Relations n) (x : Fin n → M),
    FirstOrder.Language.Structure.RelMap (fr n R) x = FirstOrder.Language.Structure.RelMap R x) (hv : ∀ (n : ℕ) (xs : Fin (k + n) → M) (x : M), v (Fin.snoc xs x) = v xs)
Goal: (FirstOrder.Language.BoundedFormula.mapTermRel ft fr (fun n => FirstOrder.Language.BoundedFormula.castLE ⋯) φ).Realize
    v' xs ↔
  φ.Realize (v xs) (xs ∘ Fin.natAdd k)
-- FirstOrder.Language.BoundedFormula.realize_relabel
@[simp]
theorem realize_relabel {m n : ℕ} {φ : L.BoundedFormula α n} {g : α → β ⊕ (Fin m)} {v : β → M}
    {xs : Fin (m + n) → M} :
    (φ.relabel g).Realize v xs ↔
      φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAdd m) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {m n : ℕ} {φ : L.BoundedFormula α n} {g : α → β ⊕ Fin m} {v : β → M} {xs : Fin (m + n) → M}
Goal: (FirstOrder.Language.BoundedFormula.relabel g φ).Realize v xs ↔
  φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAdd m)
-- FirstOrder.Language.BoundedFormula.realize_liftAt
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') 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {n n' m : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + n') → M} (hmn : m + n' ≤ n + 1)
Goal: (FirstOrder.Language.BoundedFormula.liftAt n' m φ).Realize v xs ↔
  φ.Realize v (xs ∘ fun i => if ↑i < m then Fin.castAdd n' i else i.addNat n')
-- FirstOrder.Language.BoundedFormula.realize_liftAt_one
theorem realize_liftAt_one {n m : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + 1) → M}
    (hmn : m ≤ n) :
    (φ.liftAt 1 m).Realize v xs ↔
      φ.Realize v (xs ∘ fun i => if ↑i < m then castSucc i else i.succ) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {n m : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + 1) → M} (hmn : m ≤ n)
Goal: (FirstOrder.Language.BoundedFormula.liftAt 1 m φ).Realize v xs ↔
  φ.Realize v (xs ∘ fun i => if ↑i < m then i.castSucc else i.succ)
-- FirstOrder.Language.BoundedFormula.realize_liftAt_one_self
@[simp]
theorem realize_liftAt_one_self {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
    {xs : Fin (n + 1) → M} : (φ.liftAt 1 n).Realize v xs ↔ φ.Realize v (xs ∘ castSucc) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin (n + 1) → M}
Goal: (FirstOrder.Language.BoundedFormula.liftAt 1 n φ).Realize v xs ↔ φ.Realize v (xs ∘ Fin.castSucc)
-- FirstOrder.Language.BoundedFormula.realize_subst
@[simp]
theorem realize_subst {φ : L.BoundedFormula α n} {tf : α → L.Term β} {v : β → M} {xs : Fin n → M} :
    (φ.subst tf).Realize v xs ↔ φ.Realize (fun a => (tf a).realize v) xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {n : ℕ} {φ : L.BoundedFormula α n} {tf : α → L.Term β} {v : β → M} {xs : Fin n → M}
Goal: (φ.subst tf).Realize v xs ↔ φ.Realize (fun a => FirstOrder.Language.Term.realize v (tf a)) xs
-- FirstOrder.Language.BoundedFormula.realize_restrictFreeVar
@[simp]
theorem realize_restrictFreeVar [DecidableEq α] {n : ℕ} {φ : L.BoundedFormula α n} {s : Set α}
    (h : ↑φ.freeVarFinset ⊆ s) {v : α → M} {xs : Fin n → M} :
    (φ.restrictFreeVar (Set.inclusion h)).Realize (v ∘ (↑)) xs ↔ φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} [DecidableEq α] {n : ℕ} {φ : L.BoundedFormula α n} {s : Set α} (h : ↑φ.freeVarFinset ⊆ s) {v : α → M} {xs : Fin n → M}
Goal: (φ.restrictFreeVar (Set.inclusion h)).Realize (v ∘ Subtype.val) xs ↔ φ.Realize v xs
-- FirstOrder.Language.BoundedFormula.realize_constantsVarsEquiv
theorem realize_constantsVarsEquiv [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
    {n} {φ : L[[α]].BoundedFormula β n} {v : β → M} {xs : Fin n → M} :
    (constantsVarsEquiv φ).Realize (Sum.elim (fun a => ↑(L.con a)) v) xs ↔ φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] {n : ℕ} {φ : (L.withConstants α).BoundedFormula β n} {v : β → M} {xs : Fin n → M}
Goal: (FirstOrder.Language.BoundedFormula.constantsVarsEquiv φ).Realize (Sum.elim (fun a => ↑(L.con a)) v) xs ↔ φ.Realize v xs
-- FirstOrder.Language.BoundedFormula.realize_relabelEquiv
@[simp]
theorem realize_relabelEquiv {g : α ≃ β} {k} {φ : L.BoundedFormula α k} {v : β → M}
    {xs : Fin k → M} : (relabelEquiv g φ).Realize v xs ↔ φ.Realize (v ∘ g) xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {g : α ≃ β} {k : ℕ} {φ : L.BoundedFormula α k} {v : β → M} {xs : Fin k → M}
Goal: ((FirstOrder.Language.BoundedFormula.relabelEquiv g) φ).Realize v xs ↔ φ.Realize (v ∘ ⇑g) xs
-- FirstOrder.Language.BoundedFormula.realize_all_liftAt_one_self
theorem realize_all_liftAt_one_self {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
    {xs : Fin n → M} : (φ.liftAt 1 n).all.Realize v xs ↔ φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} [Nonempty M] {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M} {xs : Fin n → M}
Goal: (FirstOrder.Language.BoundedFormula.liftAt 1 n φ).all.Realize v xs ↔ φ.Realize v xs
-- FirstOrder.Language.LHom.realize_onBoundedFormula
@[simp]
theorem realize_onBoundedFormula [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ}
    (ψ : L.BoundedFormula α n) {v : α → M} {xs : Fin n → M} :
    (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ} (ψ : L.BoundedFormula α n) {v : α → M} {xs : Fin n → M}
Goal: (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs
-- FirstOrder.Language.Formula.realize_not
@[simp]
theorem realize_not : φ.not.Realize v ↔ ¬φ.Realize v 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {φ : L.Formula α} {v : α → M}
Goal: φ.not.Realize v ↔ ¬φ.Realize v
-- FirstOrder.Language.Formula.realize_bot
@[simp]
theorem realize_bot : (⊥ : L.Formula α).Realize v ↔ False 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {v : α → M}
Goal: ⊥.Realize v ↔ False
-- FirstOrder.Language.Formula.realize_top
@[simp]
theorem realize_top : (⊤ : L.Formula α).Realize v ↔ True 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {v : α → M}
Goal: ⊤.Realize v ↔ True
-- FirstOrder.Language.Formula.realize_inf
@[simp]
theorem realize_inf : (φ ⊓ ψ).Realize v ↔ φ.Realize v ∧ ψ.Realize v 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M}
Goal: (φ ⊓ ψ).Realize v ↔ φ.Realize v ∧ ψ.Realize v
-- FirstOrder.Language.Formula.realize_imp
@[simp]
theorem realize_imp : (φ.imp ψ).Realize v ↔ φ.Realize v → ψ.Realize v 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M}
Goal: (φ.imp ψ).Realize v ↔ φ.Realize v → ψ.Realize v
-- FirstOrder.Language.Formula.realize_rel
@[simp]
theorem realize_rel {k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term α} :
    (R.formula ts).Realize v ↔ RelMap R fun i => (ts i).realize v 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {v : α → M} {k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term α}
Goal: (R.formula ts).Realize v ↔ FirstOrder.Language.Structure.RelMap R fun i => FirstOrder.Language.Term.realize v (ts i)
-- FirstOrder.Language.Formula.realize_rel₁
@[simp]
theorem realize_rel₁ {R : L.Relations 1} {t : L.Term _} :
    (R.formula₁ t).Realize v ↔ RelMap R ![t.realize v] 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {v : α → M} {R : L.Relations 1} {t : L.Term α}
Goal: (R.formula₁ t).Realize v ↔ FirstOrder.Language.Structure.RelMap R ![FirstOrder.Language.Term.realize v t]
-- FirstOrder.Language.Formula.realize_rel₂
@[simp]
theorem realize_rel₂ {R : L.Relations 2} {t₁ t₂ : L.Term _} :
    (R.formula₂ t₁ t₂).Realize v ↔ RelMap R ![t₁.realize v, t₂.realize v] 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {v : α → M} {R : L.Relations 2} {t₁ t₂ : L.Term α}
Goal: (R.formula₂ t₁ t₂).Realize v ↔
  FirstOrder.Language.Structure.RelMap R ![FirstOrder.Language.Term.realize v t₁, FirstOrder.Language.Term.realize v t₂]
-- FirstOrder.Language.Formula.realize_sup
@[simp]
theorem realize_sup : (φ ⊔ ψ).Realize v ↔ φ.Realize v ∨ ψ.Realize v 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M}
Goal: (φ ⊔ ψ).Realize v ↔ φ.Realize v ∨ ψ.Realize v
-- FirstOrder.Language.Formula.realize_iff
@[simp]
theorem realize_iff : (φ.iff ψ).Realize v ↔ (φ.Realize v ↔ ψ.Realize v) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M}
Goal: (φ.iff ψ).Realize v ↔ (φ.Realize v ↔ ψ.Realize v)
-- FirstOrder.Language.Formula.realize_relabel
@[simp]
theorem realize_relabel {φ : L.Formula α} {g : α → β} {v : β → M} :
    (φ.relabel g).Realize v ↔ φ.Realize (v ∘ g) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {φ : L.Formula α} {g : α → β} {v : β → M}
Goal: (FirstOrder.Language.Formula.relabel g φ).Realize v ↔ φ.Realize (v ∘ g)
-- FirstOrder.Language.Formula.realize_relabel_sum_inr
theorem realize_relabel_sum_inr (φ : L.Formula (Fin n)) {v : Empty → M} {x : Fin n → M} :
    (BoundedFormula.relabel Sum.inr φ).Realize v x ↔ φ.Realize x 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {n : ℕ} (φ : L.Formula (Fin n)) {v : Empty → M} {x : Fin n → M}
Goal: (FirstOrder.Language.BoundedFormula.relabel Sum.inr φ).Realize v x ↔ φ.Realize x
-- FirstOrder.Language.Formula.realize_equal
@[simp]
theorem realize_equal {t₁ t₂ : L.Term α} {x : α → M} :
    (t₁.equal t₂).Realize x ↔ t₁.realize x = t₂.realize x 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {t₁ t₂ : L.Term α} {x : α → M}
Goal: (t₁.equal t₂).Realize x ↔ FirstOrder.Language.Term.realize x t₁ = FirstOrder.Language.Term.realize x t₂
-- FirstOrder.Language.Formula.realize_graph
@[simp]
theorem realize_graph {f : L.Functions n} {x : Fin n → M} {y : M} :
    (Formula.graph f).Realize (Fin.cons y x : _ → M) ↔ funMap f x = y 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {n : ℕ} {f : L.Functions n} {x : Fin n → M} {y : M}
Goal: (FirstOrder.Language.Formula.graph f).Realize (Fin.cons y x) ↔ FirstOrder.Language.Structure.funMap f x = y
-- FirstOrder.Language.LHom.realize_onFormula
@[simp]
theorem LHom.realize_onFormula [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (ψ : L.Formula α)
    {v : α → M} : (φ.onFormula ψ).Realize v ↔ ψ.Realize v 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (ψ : L.Formula α) {v : α → M}
Goal: (φ.onFormula ψ).Realize v ↔ ψ.Realize v
-- FirstOrder.Language.LHom.setOf_realize_onFormula
@[simp]
theorem LHom.setOf_realize_onFormula [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M]
    (ψ : L.Formula α) : (setOf (φ.onFormula ψ).Realize : Set (α → M)) = setOf ψ.Realize 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (ψ : L.Formula α)
Goal: setOf (φ.onFormula ψ).Realize = setOf ψ.Realize
-- FirstOrder.Language.Sentence.realize_not
@[simp]
theorem Sentence.realize_not {φ : L.Sentence} : M ⊨ φ.not ↔ ¬M ⊨ φ 
Arguments: {L : FirstOrder.Language} (M : Type w) [L.Structure M] {φ : L.Sentence}
Goal: M ⊨ FirstOrder.Language.Formula.not φ ↔ ¬M ⊨ φ
-- FirstOrder.Language.Formula.realize_equivSentence_symm_con
@[simp]
theorem realize_equivSentence_symm_con [L[[α]].Structure M]
    [(L.lhomWithConstants α).IsExpansionOn M] (φ : L[[α]].Sentence) :
    ((equivSentence.symm φ).Realize fun a => (L.con a : M)) ↔ φ.Realize M 
Arguments: {L : FirstOrder.Language} (M : Type w) [L.Structure M] {α : Type u'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] (φ : (L.withConstants α).Sentence)
Goal: ((FirstOrder.Language.Formula.equivSentence.symm φ).Realize fun a => ↑(L.con a)) ↔ M ⊨ φ
-- FirstOrder.Language.Formula.realize_equivSentence
@[simp]
theorem realize_equivSentence [L[[α]].Structure M] [(L.lhomWithConstants α).IsExpansionOn M]
    (φ : L.Formula α) : (equivSentence φ).Realize M ↔ φ.Realize fun a => (L.con a : M) 
Arguments: {L : FirstOrder.Language} (M : Type w) [L.Structure M] {α : Type u'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] (φ : L.Formula α)
Goal: M ⊨ FirstOrder.Language.Formula.equivSentence φ ↔ φ.Realize fun a => ↑(L.con a)
-- FirstOrder.Language.Formula.realize_equivSentence_symm
theorem realize_equivSentence_symm (φ : L[[α]].Sentence) (v : α → M) :
    (equivSentence.symm φ).Realize v ↔
      @Sentence.Realize _ M (@Language.withConstantsStructure L M _ α (constantsOn.structure v))
        φ 
Arguments: {L : FirstOrder.Language} (M : Type w) [L.Structure M] {α : Type u'} (φ : (L.withConstants α).Sentence) (v : α → M)
Goal: (FirstOrder.Language.Formula.equivSentence.symm φ).Realize v ↔ M ⊨ φ
-- FirstOrder.Language.LHom.realize_onSentence
@[simp]
theorem LHom.realize_onSentence [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M]
    (ψ : L.Sentence) : M ⊨ φ.onSentence ψ ↔ M ⊨ ψ 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (M : Type w) [L.Structure M] [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (ψ : L.Sentence)
Goal: M ⊨ φ.onSentence ψ ↔ M ⊨ ψ
-- FirstOrder.Language.mem_completeTheory
@[simp]
theorem mem_completeTheory {φ : Sentence L} : φ ∈ L.completeTheory M ↔ M ⊨ φ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {φ : L.Sentence}
Goal: φ ∈ L.completeTheory M ↔ M ⊨ φ
-- FirstOrder.Language.elementarilyEquivalent_iff
theorem elementarilyEquivalent_iff : M ≅[L] N ↔ ∀ φ : L.Sentence, M ⊨ φ ↔ N ⊨ φ 
Arguments: {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [L.Structure M] [L.Structure N]
Goal: L.ElementarilyEquivalent M N ↔ ∀ (φ : L.Sentence), M ⊨ φ ↔ N ⊨ φ
-- FirstOrder.Language.Theory.Model.realize_of_mem
class Theory.Model (T : L.Theory) : Prop where
  realize_of_mem : ∀ φ ∈ T, M ⊨ φ
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T : L.Theory} [self : M ⊨ T] (φ : L.Sentence)
Goal: φ ∈ T → M ⊨ φ
-- FirstOrder.Language.Theory.model_iff
@[simp default-10]
theorem Theory.model_iff : M ⊨ T ↔ ∀ φ ∈ T, M ⊨ φ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (T : L.Theory)
Goal: M ⊨ T ↔ ∀ φ ∈ T, M ⊨ φ
-- FirstOrder.Language.Theory.realize_sentence_of_mem
theorem Theory.realize_sentence_of_mem [M ⊨ T] {φ : L.Sentence} (h : φ ∈ T) : M ⊨ φ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (T : L.Theory) [M ⊨ T] {φ : L.Sentence} (h : φ ∈ T)
Goal: M ⊨ φ
-- FirstOrder.Language.LHom.onTheory_model
@[simp]
theorem LHom.onTheory_model [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (T : L.Theory) :
    M ⊨ φ.onTheory T ↔ M ⊨ T 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [L.Structure M] [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (T : L.Theory)
Goal: M ⊨ φ.onTheory T ↔ M ⊨ T
-- FirstOrder.Language.Theory.Model.mono
theorem Model.mono {T' : L.Theory} (_h : M ⊨ T') (hs : T ⊆ T') : M ⊨ T 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T T' : L.Theory} (_h : M ⊨ T') (hs : T ⊆ T')
Goal: M ⊨ T
-- FirstOrder.Language.Theory.Model.union
theorem Model.union {T' : L.Theory} (h : M ⊨ T) (h' : M ⊨ T') : M ⊨ T ∪ T' 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T T' : L.Theory} (h : M ⊨ T) (h' : M ⊨ T')
Goal: M ⊨ T ∪ T'
-- FirstOrder.Language.Theory.model_union_iff
@[simp]
theorem model_union_iff {T' : L.Theory} : M ⊨ T ∪ T' ↔ M ⊨ T ∧ M ⊨ T' 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T T' : L.Theory}
Goal: M ⊨ T ∪ T' ↔ M ⊨ T ∧ M ⊨ T'
-- FirstOrder.Language.Theory.model_singleton_iff
theorem model_singleton_iff {φ : L.Sentence} : M ⊨ ({φ} : L.Theory) ↔ M ⊨ φ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {φ : L.Sentence}
Goal: M ⊨ {φ} ↔ M ⊨ φ
-- FirstOrder.Language.Theory.model_iff_subset_completeTheory
theorem model_iff_subset_completeTheory : M ⊨ T ↔ T ⊆ L.completeTheory M 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T : L.Theory}
Goal: M ⊨ T ↔ T ⊆ L.completeTheory M
-- FirstOrder.Language.Theory.completeTheory.subset
theorem completeTheory.subset [MT : M ⊨ T] : T ⊆ L.completeTheory M 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {T : L.Theory} [MT : M ⊨ T]
Goal: T ⊆ L.completeTheory M
-- FirstOrder.Language.realize_iff_of_model_completeTheory
theorem realize_iff_of_model_completeTheory [N ⊨ L.completeTheory M] (φ : L.Sentence) :
    N ⊨ φ ↔ M ⊨ φ 
Arguments: {L : FirstOrder.Language} (M : Type w) (N : Type u_1) [L.Structure M] [L.Structure N] [N ⊨ L.completeTheory M] (φ : L.Sentence)
Goal: N ⊨ φ ↔ M ⊨ φ
-- FirstOrder.Language.BoundedFormula.realize_alls
@[simp]
theorem realize_alls {φ : L.BoundedFormula α n} {v : α → M} :
    φ.alls.Realize v ↔ ∀ xs : Fin n → M, φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
Goal: φ.alls.Realize v ↔ ∀ (xs : Fin n → M), φ.Realize v xs
-- FirstOrder.Language.BoundedFormula.realize_exs
@[simp]
theorem realize_exs {φ : L.BoundedFormula α n} {v : α → M} :
    φ.exs.Realize v ↔ ∃ xs : Fin n → M, φ.Realize v xs 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
Goal: φ.exs.Realize v ↔ ∃ xs, φ.Realize v xs
-- FirstOrder.Language.Formula.realize_iAlls
@[simp]
theorem _root_.FirstOrder.Language.Formula.realize_iAlls
    [Finite γ] {f : α → β ⊕ γ}
    {φ : L.Formula α} {v : β → M} : (φ.iAlls f).Realize v ↔
      ∀ (i : γ → M), φ.Realize (fun a => Sum.elim v i (f a)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {γ : Type u_3} [Finite γ] {f : α → β ⊕ γ} {φ : L.Formula α} {v : β → M}
Goal: (FirstOrder.Language.Formula.iAlls f φ).Realize v ↔ ∀ (i : γ → M), φ.Realize fun a => Sum.elim v i (f a)
-- FirstOrder.Language.BoundedFormula.realize_iAlls
@[simp]
theorem realize_iAlls [Finite γ] {f : α → β ⊕ γ}
    {φ : L.Formula α} {v : β → M} {v' : Fin 0 → M} :
    BoundedFormula.Realize (φ.iAlls f) v v' ↔
      ∀ (i : γ → M), φ.Realize (fun a => Sum.elim v i (f a)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {γ : Type u_3} [Finite γ] {f : α → β ⊕ γ} {φ : L.Formula α} {v : β → M} {v' : Fin 0 → M}
Goal: FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Formula.iAlls f φ) v v' ↔
  ∀ (i : γ → M), φ.Realize fun a => Sum.elim v i (f a)
-- FirstOrder.Language.Formula.realize_iExs
@[simp]
theorem _root_.FirstOrder.Language.Formula.realize_iExs
    [Finite γ] {f : α → β ⊕ γ}
    {φ : L.Formula α} {v : β → M} : (φ.iExs f).Realize v ↔
      ∃ (i : γ → M), φ.Realize (fun a => Sum.elim v i (f a)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {α : Type u'} {β : Type v'} {γ : Type u_3} [Finite γ] {f : α → β ⊕ γ} {φ : L.Formula α} {v : β → M}
Goal: (FirstOrder.Language.Formula.iExs f φ).Realize v ↔ ∃ i, φ.Realize fun a => Sum.elim v i (f a)