ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.Mathlib.ModelTheory.Algebra.Ring.FreeCommRing.0.FirstOrder.Ring.exists_term_realize_eq_freeCommRing
private theorem exists_term_realize_eq_freeCommRing (p : FreeCommRing α) :
    ∃ t : Language.ring.Term α,
      (t.realize FreeCommRing.of : FreeCommRing α) = p 
Arguments: {α : Type u_1} (p : FreeCommRing α)
Goal: ∃ t, FirstOrder.Language.Term.realize FreeCommRing.of t = p
-- FirstOrder.Ring.realize_termOfFreeCommRing
@[simp]
theorem realize_termOfFreeCommRing (p : FreeCommRing α) (v : α → R) :
    (termOfFreeCommRing p).realize v = FreeCommRing.lift v p 
Arguments: {α : Type u_1} {R : Type u_2} [CommRing R] [FirstOrder.Ring.CompatibleRing R] (p : FreeCommRing α) (v : α → R)
Goal: FirstOrder.Language.Term.realize v (FirstOrder.Ring.termOfFreeCommRing p) = (FreeCommRing.lift v) p
-- FirstOrder.Ring.zero_def
theorem zero_def (α : Type*) : (0 : Language.ring.Term α) = Constants.term zeroFunc 
Arguments: (α : Type u_2)
Goal: 0 = FirstOrder.Language.Constants.term FirstOrder.Ring.zeroFunc
-- FirstOrder.Ring.one_def
theorem one_def (α : Type*) : (1 : Language.ring.Term α) = Constants.term oneFunc 
Arguments: (α : Type u_2)
Goal: 1 = FirstOrder.Language.Constants.term FirstOrder.Ring.oneFunc
-- FirstOrder.Ring.add_def
theorem add_def (α : Type*) (t₁ t₂ : Language.ring.Term α) :
    t₁ + t₂ = addFunc.apply₂ t₁ t₂ 
Arguments: (α : Type u_2) (t₁ t₂ : FirstOrder.Language.ring.Term α)
Goal: t₁ + t₂ = FirstOrder.Ring.addFunc.apply₂ t₁ t₂
-- FirstOrder.Ring.mul_def
theorem mul_def (α : Type*) (t₁ t₂ : Language.ring.Term α) :
    t₁ * t₂ = mulFunc.apply₂ t₁ t₂ 
Arguments: (α : Type u_2) (t₁ t₂ : FirstOrder.Language.ring.Term α)
Goal: t₁ * t₂ = FirstOrder.Ring.mulFunc.apply₂ t₁ t₂
-- FirstOrder.Ring.neg_def
theorem neg_def (α : Type*) (t : Language.ring.Term α) :
    -t = negFunc.apply₁ t 
Arguments: (α : Type u_2) (t : FirstOrder.Language.ring.Term α)
Goal: -t = FirstOrder.Ring.negFunc.apply₁ t
-- FirstOrder.Ring.card_ring
@[simp]
theorem card_ring : card Language.ring = 5 
Goal: FirstOrder.Language.ring.card = 5
-- FirstOrder.Ring.CompatibleRing.funMap_neg
/- This class does not extend `Add` etc, because this way it can be used in
combination with a `Ring`, or `Field` instance without having multiple different
`Add` structures on the Type. -/
class CompatibleRing (R : Type*) [Add R] [Mul R] [Neg R] [One R] [Zero R]
    extends Language.ring.Structure R where
    funMap_add : ∀ x, funMap addFunc x = x 0 + x 1
    funMap_mul : ∀ x, funMap mulFunc x = x 0 * x 1
    funMap_neg : ∀ x, funMap negFunc x = -x 0
    funMap_zero : ∀ x, funMap (zeroFunc : Language.ring.Constants) x = 0
    funMap_one : ∀ x, funMap (oneFunc : Language.ring.Constants) x = 1
Arguments: {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [self : FirstOrder.Ring.CompatibleRing R] (x : Fin 1 → R)
Goal: FirstOrder.Language.Structure.funMap FirstOrder.Ring.negFunc x = -x 0
-- FirstOrder.Ring.CompatibleRing.funMap_zero
/- This class does not extend `Add` etc, because this way it can be used in
combination with a `Ring`, or `Field` instance without having multiple different
`Add` structures on the Type. -/
class CompatibleRing (R : Type*) [Add R] [Mul R] [Neg R] [One R] [Zero R]
    extends Language.ring.Structure R where
    funMap_add : ∀ x, funMap addFunc x = x 0 + x 1
    funMap_mul : ∀ x, funMap mulFunc x = x 0 * x 1
    funMap_neg : ∀ x, funMap negFunc x = -x 0
    funMap_zero : ∀ x, funMap (zeroFunc : Language.ring.Constants) x = 0
    funMap_one : ∀ x, funMap (oneFunc : Language.ring.Constants) x = 1
Arguments: {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [self : FirstOrder.Ring.CompatibleRing R] (x : Fin 0 → R)
Goal: FirstOrder.Language.Structure.funMap FirstOrder.Ring.zeroFunc x = 0
-- FirstOrder.Ring.CompatibleRing.funMap_one
/- This class does not extend `Add` etc, because this way it can be used in
combination with a `Ring`, or `Field` instance without having multiple different
`Add` structures on the Type. -/
class CompatibleRing (R : Type*) [Add R] [Mul R] [Neg R] [One R] [Zero R]
    extends Language.ring.Structure R where
    funMap_add : ∀ x, funMap addFunc x = x 0 + x 1
    funMap_mul : ∀ x, funMap mulFunc x = x 0 * x 1
    funMap_neg : ∀ x, funMap negFunc x = -x 0
    funMap_zero : ∀ x, funMap (zeroFunc : Language.ring.Constants) x = 0
    funMap_one : ∀ x, funMap (oneFunc : Language.ring.Constants) x = 1
Arguments: {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [self : FirstOrder.Ring.CompatibleRing R] (x : Fin 0 → R)
Goal: FirstOrder.Language.Structure.funMap FirstOrder.Ring.oneFunc x = 1
-- FirstOrder.Ring.CompatibleRing.funMap_mul
/- This class does not extend `Add` etc, because this way it can be used in
combination with a `Ring`, or `Field` instance without having multiple different
`Add` structures on the Type. -/
class CompatibleRing (R : Type*) [Add R] [Mul R] [Neg R] [One R] [Zero R]
    extends Language.ring.Structure R where
    funMap_add : ∀ x, funMap addFunc x = x 0 + x 1
    funMap_mul : ∀ x, funMap mulFunc x = x 0 * x 1
    funMap_neg : ∀ x, funMap negFunc x = -x 0
    funMap_zero : ∀ x, funMap (zeroFunc : Language.ring.Constants) x = 0
    funMap_one : ∀ x, funMap (oneFunc : Language.ring.Constants) x = 1
Arguments: {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [self : FirstOrder.Ring.CompatibleRing R] (x : Fin 2 → R)
Goal: FirstOrder.Language.Structure.funMap FirstOrder.Ring.mulFunc x = x 0 * x 1
-- FirstOrder.Ring.CompatibleRing.funMap_add
/- This class does not extend `Add` etc, because this way it can be used in
combination with a `Ring`, or `Field` instance without having multiple different
`Add` structures on the Type. -/
class CompatibleRing (R : Type*) [Add R] [Mul R] [Neg R] [One R] [Zero R]
    extends Language.ring.Structure R where
    funMap_add : ∀ x, funMap addFunc x = x 0 + x 1
    funMap_mul : ∀ x, funMap mulFunc x = x 0 * x 1
    funMap_neg : ∀ x, funMap negFunc x = -x 0
    funMap_zero : ∀ x, funMap (zeroFunc : Language.ring.Constants) x = 0
    funMap_one : ∀ x, funMap (oneFunc : Language.ring.Constants) x = 1
Arguments: {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [self : FirstOrder.Ring.CompatibleRing R] (x : Fin 2 → R)
Goal: FirstOrder.Language.Structure.funMap FirstOrder.Ring.addFunc x = x 0 + x 1
-- FirstOrder.Ring.realize_add
@[simp]
theorem realize_add (x y : ring.Term α) (v : α → R) :
    Term.realize v (x + y) = Term.realize v x + Term.realize v y 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [FirstOrder.Ring.CompatibleRing R] (x y : FirstOrder.Language.ring.Term α) (v : α → R)
Goal: FirstOrder.Language.Term.realize v (x + y) = FirstOrder.Language.Term.realize v x + FirstOrder.Language.Term.realize v y
-- FirstOrder.Ring.realize_mul
@[simp]
theorem realize_mul (x y : ring.Term α) (v : α → R) :
    Term.realize v (x * y) = Term.realize v x * Term.realize v y 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [FirstOrder.Ring.CompatibleRing R] (x y : FirstOrder.Language.ring.Term α) (v : α → R)
Goal: FirstOrder.Language.Term.realize v (x * y) = FirstOrder.Language.Term.realize v x * FirstOrder.Language.Term.realize v y
-- FirstOrder.Ring.realize_neg
@[simp]
theorem realize_neg (x : ring.Term α) (v : α → R) :
    Term.realize v (-x) = -Term.realize v x 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [FirstOrder.Ring.CompatibleRing R] (x : FirstOrder.Language.ring.Term α) (v : α → R)
Goal: FirstOrder.Language.Term.realize v (-x) = -FirstOrder.Language.Term.realize v x
-- FirstOrder.Ring.realize_zero
@[simp]
theorem realize_zero (v : α → R) : Term.realize v (0 : ring.Term α) = 0 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [FirstOrder.Ring.CompatibleRing R] (v : α → R)
Goal: FirstOrder.Language.Term.realize v 0 = 0
-- FirstOrder.Ring.realize_one
@[simp]
theorem realize_one (v : α → R) : Term.realize v (1 : ring.Term α) = 1 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [Mul R] [Neg R] [One R] [Zero R] [FirstOrder.Ring.CompatibleRing R] (v : α → R)
Goal: FirstOrder.Language.Term.realize v 1 = 1
-- FirstOrder.Language.Prestructure.fun_equiv
class Prestructure (s : Setoid M) where
  toStructure : L.Structure M
  fun_equiv : ∀ {n} {f : L.Functions n} (x y : Fin n → M), x ≈ y → funMap f x ≈ funMap f y
  rel_equiv : ∀ {n} {r : L.Relations n} (x y : Fin n → M) (_ : x ≈ y), RelMap r x = RelMap r y
Arguments: {L : FirstOrder.Language} {M : Type u_1} {s : Setoid M} [self : L.Prestructure s] {n : ℕ} {f : L.Functions n} (x y : Fin n → M)
Goal: x ≈ y → FirstOrder.Language.Structure.funMap f x ≈ FirstOrder.Language.Structure.funMap f y
-- FirstOrder.Language.Prestructure.rel_equiv
class Prestructure (s : Setoid M) where
  toStructure : L.Structure M
  fun_equiv : ∀ {n} {f : L.Functions n} (x y : Fin n → M), x ≈ y → funMap f x ≈ funMap f y
  rel_equiv : ∀ {n} {r : L.Relations n} (x y : Fin n → M) (_ : x ≈ y), RelMap r x = RelMap r y
Arguments: {L : FirstOrder.Language} {M : Type u_1} {s : Setoid M} [self : L.Prestructure s] {n : ℕ} {r : L.Relations n} (x y : Fin n → M)
Goal: x ≈ y → FirstOrder.Language.Structure.RelMap r x = FirstOrder.Language.Structure.RelMap r y
-- FirstOrder.Language.funMap_quotient_mk'
theorem funMap_quotient_mk' {n : ℕ} (f : L.Functions n) (x : Fin n → M) :
    (funMap f fun i => (⟦x i⟧ : Quotient s)) = ⟦@funMap _ _ ps.toStructure _ f x⟧ 
Arguments: {L : FirstOrder.Language} {M : Type u_1} (s : Setoid M) [ps : L.Prestructure s] {n : ℕ} (f : L.Functions n) (x : Fin n → M)
Goal: (FirstOrder.Language.Structure.funMap f fun i => ⟦x i⟧) = ⟦FirstOrder.Language.Structure.funMap f x⟧
-- FirstOrder.Language.relMap_quotient_mk'
theorem relMap_quotient_mk' {n : ℕ} (r : L.Relations n) (x : Fin n → M) :
    (RelMap r fun i => (⟦x i⟧ : Quotient s)) ↔ @RelMap _ _ ps.toStructure _ r x 
Arguments: {L : FirstOrder.Language} {M : Type u_1} (s : Setoid M) [ps : L.Prestructure s] {n : ℕ} (r : L.Relations n) (x : Fin n → M)
Goal: (FirstOrder.Language.Structure.RelMap r fun i => ⟦x i⟧) ↔ FirstOrder.Language.Structure.RelMap r x
-- FirstOrder.Language.Term.realize_quotient_mk'
theorem Term.realize_quotient_mk' {β : Type*} (t : L.Term β) (x : β → M) :
    (t.realize fun i => (⟦x i⟧ : Quotient s)) = ⟦@Term.realize _ _ ps.toStructure _ x t⟧ 
Arguments: {L : FirstOrder.Language} {M : Type u_1} (s : Setoid M) [ps : L.Prestructure s] {β : Type u_2} (t : L.Term β) (x : β → M)
Goal: FirstOrder.Language.Term.realize (fun i => ⟦x i⟧) t = ⟦FirstOrder.Language.Term.realize x t⟧
-- FirstOrder.Language.Substructure.fg_def
theorem fg_def {N : L.Substructure M} : N.FG ↔ ∃ S : Set M, S.Finite ∧ closure L S = N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : L.Substructure M}
Goal: N.FG ↔ ∃ S, S.Finite ∧ (FirstOrder.Language.Substructure.closure L).toFun S = N
-- FirstOrder.Language.Substructure.fg_iff_exists_fin_generating_family
theorem fg_iff_exists_fin_generating_family {N : L.Substructure M} :
    N.FG ↔ ∃ (n : ℕ) (s : Fin n → M), closure L (range s) = N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : L.Substructure M}
Goal: N.FG ↔ ∃ n s, (FirstOrder.Language.Substructure.closure L).toFun (Set.range s) = N
-- FirstOrder.Language.Substructure.fg_bot
theorem fg_bot : (⊥ : L.Substructure M).FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: ⊥.FG
-- FirstOrder.Language.Substructure.fg_closure
theorem fg_closure {s : Set M} (hs : s.Finite) : FG (closure L s) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {s : Set M} (hs : s.Finite)
Goal: ((FirstOrder.Language.Substructure.closure L).toFun s).FG
-- FirstOrder.Language.Substructure.fg_closure_singleton
theorem fg_closure_singleton (x : M) : FG (closure L ({x} : Set M)) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] (x : M)
Goal: ((FirstOrder.Language.Substructure.closure L).toFun {x}).FG
-- FirstOrder.Language.Substructure.FG.sup
theorem FG.sup {N₁ N₂ : L.Substructure M} (hN₁ : N₁.FG) (hN₂ : N₂.FG) : (N₁ ⊔ N₂).FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N₁ N₂ : L.Substructure M} (hN₁ : N₁.FG) (hN₂ : N₂.FG)
Goal: (N₁ ⊔ N₂).FG
-- FirstOrder.Language.Substructure.FG.map
theorem FG.map {N : Type*} [L.Structure N] (f : M →[L] N) {s : L.Substructure M} (hs : s.FG) :
    (s.map f).FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M →[L] N) {s : L.Substructure M} (hs : s.FG)
Goal: (FirstOrder.Language.Substructure.map f s).FG
-- FirstOrder.Language.Substructure.FG.of_map_embedding
theorem FG.of_map_embedding {N : Type*} [L.Structure N] (f : M ↪[L] N) {s : L.Substructure M}
    (hs : (s.map f.toHom).FG) : s.FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M ↪[L] N) {s : L.Substructure M} (hs : (FirstOrder.Language.Substructure.map f.toHom s).FG)
Goal: s.FG
-- FirstOrder.Language.Substructure.cg_def
theorem cg_def {N : L.Substructure M} : N.CG ↔ ∃ S : Set M, S.Countable ∧ closure L S = N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : L.Substructure M}
Goal: N.CG ↔ ∃ S, S.Countable ∧ (FirstOrder.Language.Substructure.closure L).toFun S = N
-- FirstOrder.Language.Substructure.FG.cg
theorem FG.cg {N : L.Substructure M} (h : N.FG) : N.CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : L.Substructure M} (h : N.FG)
Goal: N.CG
-- FirstOrder.Language.Substructure.cg_iff_empty_or_exists_nat_generating_family
theorem cg_iff_empty_or_exists_nat_generating_family {N : L.Substructure M} :
    N.CG ↔ N = (∅ : Set M) ∨ ∃ s : ℕ → M, closure L (range s) = N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : L.Substructure M}
Goal: N.CG ↔ ↑N = ∅ ∨ ∃ s, (FirstOrder.Language.Substructure.closure L).toFun (Set.range s) = N
-- FirstOrder.Language.Substructure.cg_bot
theorem cg_bot : (⊥ : L.Substructure M).CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: ⊥.CG
-- FirstOrder.Language.Substructure.cg_closure
theorem cg_closure {s : Set M} (hs : s.Countable) : CG (closure L s) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {s : Set M} (hs : s.Countable)
Goal: ((FirstOrder.Language.Substructure.closure L).toFun s).CG
-- FirstOrder.Language.Substructure.cg_closure_singleton
theorem cg_closure_singleton (x : M) : CG (closure L ({x} : Set M)) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] (x : M)
Goal: ((FirstOrder.Language.Substructure.closure L).toFun {x}).CG
-- FirstOrder.Language.Substructure.CG.sup
theorem CG.sup {N₁ N₂ : L.Substructure M} (hN₁ : N₁.CG) (hN₂ : N₂.CG) : (N₁ ⊔ N₂).CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N₁ N₂ : L.Substructure M} (hN₁ : N₁.CG) (hN₂ : N₂.CG)
Goal: (N₁ ⊔ N₂).CG
-- FirstOrder.Language.Substructure.CG.map
theorem CG.map {N : Type*} [L.Structure N] (f : M →[L] N) {s : L.Substructure M} (hs : s.CG) :
    (s.map f).CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M →[L] N) {s : L.Substructure M} (hs : s.CG)
Goal: (FirstOrder.Language.Substructure.map f s).CG
-- FirstOrder.Language.Substructure.CG.of_map_embedding
theorem CG.of_map_embedding {N : Type*} [L.Structure N] (f : M ↪[L] N) {s : L.Substructure M}
    (hs : (s.map f.toHom).CG) : s.CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M ↪[L] N) {s : L.Substructure M} (hs : (FirstOrder.Language.Substructure.map f.toHom s).CG)
Goal: s.CG
-- FirstOrder.Language.Substructure.cg_iff_countable
theorem cg_iff_countable [Countable (Σl, L.Functions l)] {s : L.Substructure M} :
    s.CG ↔ Countable s 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] [Countable ((l : ℕ) × L.Functions l)] {s : L.Substructure M}
Goal: s.CG ↔ Countable ↥s
-- FirstOrder.Language.Structure.FG.out
class FG : Prop where
  out : (⊤ : L.Substructure M).FG
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] [self : FirstOrder.Language.Structure.FG L M]
Goal: ⊤.FG
-- FirstOrder.Language.Structure.CG.out
class CG : Prop where
  out : (⊤ : L.Substructure M).CG
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] [self : FirstOrder.Language.Structure.CG L M]
Goal: ⊤.CG
-- FirstOrder.Language.Structure.fg_def
theorem fg_def : FG L M ↔ (⊤ : L.Substructure M).FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: FirstOrder.Language.Structure.FG L M ↔ ⊤.FG
-- FirstOrder.Language.Structure.fg_iff
theorem fg_iff : FG L M ↔ ∃ S : Set M, S.Finite ∧ closure L S = (⊤ : L.Substructure M) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: FirstOrder.Language.Structure.FG L M ↔ ∃ S, S.Finite ∧ (FirstOrder.Language.Substructure.closure L).toFun S = ⊤
-- FirstOrder.Language.Structure.FG.range
theorem FG.range {N : Type*} [L.Structure N] (h : FG L M) (f : M →[L] N) : f.range.FG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (h : FirstOrder.Language.Structure.FG L M) (f : M →[L] N)
Goal: f.range.FG
-- FirstOrder.Language.Structure.FG.map_of_surjective
theorem FG.map_of_surjective {N : Type*} [L.Structure N] (h : FG L M) (f : M →[L] N)
    (hs : Function.Surjective f) : FG L N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (h : FirstOrder.Language.Structure.FG L M) (f : M →[L] N) (hs : Function.Surjective ⇑f)
Goal: FirstOrder.Language.Structure.FG L N
-- FirstOrder.Language.Structure.cg_def
theorem cg_def : CG L M ↔ (⊤ : L.Substructure M).CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: FirstOrder.Language.Structure.CG L M ↔ ⊤.CG
-- FirstOrder.Language.Structure.cg_iff
theorem cg_iff : CG L M ↔ ∃ S : Set M, S.Countable ∧ closure L S = (⊤ : L.Substructure M) 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M]
Goal: FirstOrder.Language.Structure.CG L M ↔ ∃ S, S.Countable ∧ (FirstOrder.Language.Substructure.closure L).toFun S = ⊤
-- FirstOrder.Language.Structure.CG.range
theorem CG.range {N : Type*} [L.Structure N] (h : CG L M) (f : M →[L] N) : f.range.CG 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (h : FirstOrder.Language.Structure.CG L M) (f : M →[L] N)
Goal: f.range.CG
-- FirstOrder.Language.Structure.CG.map_of_surjective
theorem CG.map_of_surjective {N : Type*} [L.Structure N] (h : CG L M) (f : M →[L] N)
    (hs : Function.Surjective f) : CG L N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (h : FirstOrder.Language.Structure.CG L M) (f : M →[L] N) (hs : Function.Surjective ⇑f)
Goal: FirstOrder.Language.Structure.CG L N
-- FirstOrder.Language.Structure.cg_iff_countable
theorem cg_iff_countable [Countable (Σl, L.Functions l)] : CG L M ↔ Countable M 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] [Countable ((l : ℕ) × L.Functions l)]
Goal: FirstOrder.Language.Structure.CG L M ↔ Countable M
-- FirstOrder.Language.Structure.FG.cg
theorem FG.cg (h : FG L M) : CG L M 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] (h : FirstOrder.Language.Structure.FG L M)
Goal: FirstOrder.Language.Structure.CG L M
-- FirstOrder.Language.Equiv.fg_iff
theorem Equiv.fg_iff {N : Type*} [L.Structure N] (f : M ≃[L] N) :
    Structure.FG L M ↔ Structure.FG L N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M ≃[L] N)
Goal: FirstOrder.Language.Structure.FG L M ↔ FirstOrder.Language.Structure.FG L N
-- FirstOrder.Language.Substructure.fg_iff_structure_fg
theorem Substructure.fg_iff_structure_fg (S : L.Substructure M) : S.FG ↔ Structure.FG L S 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] (S : L.Substructure M)
Goal: S.FG ↔ FirstOrder.Language.Structure.FG L ↥S
-- FirstOrder.Language.Equiv.cg_iff
theorem Equiv.cg_iff {N : Type*} [L.Structure N] (f : M ≃[L] N) :
    Structure.CG L M ↔ Structure.CG L N 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] {N : Type u_2} [L.Structure N] (f : M ≃[L] N)
Goal: FirstOrder.Language.Structure.CG L M ↔ FirstOrder.Language.Structure.CG L N
-- FirstOrder.Language.Substructure.cg_iff_structure_cg
theorem Substructure.cg_iff_structure_cg (S : L.Substructure M) : S.CG ↔ Structure.CG L S 
Arguments: {L : FirstOrder.Language} {M : Type u_1} [L.Structure M] (S : L.Substructure M)
Goal: S.CG ↔ FirstOrder.Language.Structure.CG L ↥S
-- FirstOrder.Field.FieldAxiom.realize_toSentence_iff_toProp
theorem FieldAxiom.realize_toSentence_iff_toProp {K : Type*}
    [Add K] [Mul K] [Neg K] [Zero K] [One K] [CompatibleRing K]
    (ax : FieldAxiom) :
    (K ⊨ (ax.toSentence : Sentence Language.ring)) ↔ ax.toProp K 
Arguments: {K : Type u_2} [Add K] [Mul K] [Neg K] [Zero K] [One K] [FirstOrder.Ring.CompatibleRing K] (ax : FirstOrder.Field.FieldAxiom)
Goal: K ⊨ ax.toSentence ↔ FirstOrder.Field.FieldAxiom.toProp K ax
-- FirstOrder.Field.FieldAxiom.toProp_of_model
theorem FieldAxiom.toProp_of_model {K : Type*}
    [Add K] [Mul K] [Neg K] [Zero K] [One K] [CompatibleRing K]
    [Theory.field.Model K] (ax : FieldAxiom) : ax.toProp K 
Arguments: {K : Type u_2} [Add K] [Mul K] [Neg K] [Zero K] [One K] [FirstOrder.Ring.CompatibleRing K] [K ⊨ FirstOrder.Language.Theory.field] (ax : FirstOrder.Field.FieldAxiom)
Goal: FirstOrder.Field.FieldAxiom.toProp K ax
-- FirstOrder.Language.LHom.id_onRelation
@[simps]
protected def id (L : Language) : L →ᴸ L 
Arguments: (L : FirstOrder.Language) (_n : ℕ) (a : L.Relations _n)
Goal: (FirstOrder.Language.LHom.id L).onRelation a = id a
-- FirstOrder.Language.LHom.id_onFunction
@[simps]
protected def id (L : Language) : L →ᴸ L 
Arguments: (L : FirstOrder.Language) (_n : ℕ) (a : L.Functions _n)
Goal: (FirstOrder.Language.LHom.id L).onFunction a = id a
-- FirstOrder.Language.LHom.sumInl_onFunction
@[simps]
protected def sumInl : L →ᴸ L.sum L' 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L.Functions _n)
Goal: FirstOrder.Language.LHom.sumInl.onFunction val = Sum.inl val
-- FirstOrder.Language.LHom.sumInl_onRelation
@[simps]
protected def sumInl : L →ᴸ L.sum L' 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L.Relations _n)
Goal: FirstOrder.Language.LHom.sumInl.onRelation val = Sum.inl val
-- FirstOrder.Language.LHom.sumInr_onFunction
@[simps]
protected def sumInr : L' →ᴸ L.sum L' 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L'.Functions _n)
Goal: FirstOrder.Language.LHom.sumInr.onFunction val = Sum.inr val
-- FirstOrder.Language.LHom.sumInr_onRelation
@[simps]
protected def sumInr : L' →ᴸ L.sum L' 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L'.Relations _n)
Goal: FirstOrder.Language.LHom.sumInr.onRelation val = Sum.inr val
-- FirstOrder.Language.LHom.ofIsEmpty_onRelation
@[simps]
protected def ofIsEmpty [L.IsAlgebraic] [L.IsRelational] : L →ᴸ L' 
Arguments: (L : FirstOrder.Language) (L' : FirstOrder.Language) [L.IsAlgebraic] [L.IsRelational] (n : ℕ) (a : L.Relations n)
Goal: (FirstOrder.Language.LHom.ofIsEmpty L L').onRelation a = ⋯.elim a
-- FirstOrder.Language.LHom.ofIsEmpty_onFunction
@[simps]
protected def ofIsEmpty [L.IsAlgebraic] [L.IsRelational] : L →ᴸ L' 
Arguments: (L : FirstOrder.Language) (L' : FirstOrder.Language) [L.IsAlgebraic] [L.IsRelational] (n : ℕ) (a : L.Functions n)
Goal: (FirstOrder.Language.LHom.ofIsEmpty L L').onFunction a = ⋯.elim a
-- FirstOrder.Language.LHom.funext
@[ext]
protected theorem funext {F G : L →ᴸ L'} (h_fun : F.onFunction = G.onFunction)
    (h_rel : F.onRelation = G.onRelation) : F = G 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} {F G : L →ᴸ L'} (h_fun : F.onFunction = G.onFunction) (h_rel : F.onRelation = G.onRelation)
Goal: F = G