File: Mathlib/ModelTheory/Syntax.lean

full_name: FirstOrder.Language.Term
code: /-- A term on `α` is either a variable indexed by an element of `α`
  or a function symbol applied to simpler terms. -/
inductive Term (α : Type u') : Type max u u'
  | var : α → Term α
  | func : ∀ {l : ℕ} (_f : L.Functions l) (_ts : Fin l → Term α), Term α
goal: Type (max u u')

full_name: FirstOrder.Language.Term.var
code: /-- A term on `α` is either a variable indexed by an element of `α`
  or a function symbol applied to simpler terms. -/
inductive Term (α : Type u') : Type max u u'
  | var : α → Term α
  | func : ∀ {l : ℕ} (_f : L.Functions l) (_ts : Fin l → Term α), Term α
goal: α → L.Term α

full_name: FirstOrder.Language.Term.func
code: /-- A term on `α` is either a variable indexed by an element of `α`
  or a function symbol applied to simpler terms. -/
inductive Term (α : Type u') : Type max u u'
  | var : α → Term α
  | func : ∀ {l : ℕ} (_f : L.Functions l) (_ts : Fin l → Term α), Term α
goal: L.Term α

full_name: FirstOrder.Language.Term.varFinset
code: /-- The `Finset` of variables used in a given term. -/
@[simp]
def varFinset [DecidableEq α] : L.Term α → Finset α
  
goal: L.Term α → Finset α

full_name: FirstOrder.Language.Term.varFinsetLeft
code: /-- The `Finset` of variables from the left side of a sum used in a given term. -/
@[simp]
def varFinsetLeft [DecidableEq α] : L.Term (α ⊕ β) → Finset α
  
goal: L.Term (α ⊕ β) → Finset α

full_name: FirstOrder.Language.Term.relabel
code: @[simp]
def relabel (g : α → β) : L.Term α → L.Term β
  
goal: L.Term α → L.Term β

full_name: FirstOrder.Language.Term.relabel_id
code: theorem relabel_id (t : L.Term α) : t.relabel id = t 
goal: FirstOrder.Language.Term.relabel id t = t

full_name: FirstOrder.Language.Term.relabel_id_eq_id
code: @[simp]
theorem relabel_id_eq_id : (Term.relabel id : L.Term α → L.Term α) = id 
goal: FirstOrder.Language.Term.relabel id = id

full_name: FirstOrder.Language.Term.relabel_relabel
code: @[simp]
theorem relabel_relabel (f : α → β) (g : β → γ) (t : L.Term α) :
    (t.relabel f).relabel g = t.relabel (g ∘ f) 
goal: FirstOrder.Language.Term.relabel g (FirstOrder.Language.Term.relabel f t) = FirstOrder.Language.Term.relabel (g ∘ f) t

full_name: FirstOrder.Language.Term.relabel_comp_relabel
code: @[simp]
theorem relabel_comp_relabel (f : α → β) (g : β → γ) :
    (Term.relabel g ∘ Term.relabel f : L.Term α → L.Term γ) = Term.relabel (g ∘ f) 
goal: FirstOrder.Language.Term.relabel g ∘ FirstOrder.Language.Term.relabel f = FirstOrder.Language.Term.relabel (g ∘ f)

full_name: FirstOrder.Language.Term.relabelEquiv_apply
code: /-- Relabels a term's variables along a bijection. -/
@[simps]
def relabelEquiv (g : α ≃ β) : L.Term α ≃ L.Term β 
goal: ∀ (a : L.Term α), (FirstOrder.Language.Term.relabelEquiv g) a = FirstOrder.Language.Term.relabel (⇑g) a

full_name: FirstOrder.Language.Term.relabelEquiv
code: /-- Relabels a term's variables along a bijection. -/
@[simps]
def relabelEquiv (g : α ≃ β) : L.Term α ≃ L.Term β 
goal: L.Term α ≃ L.Term β

full_name: FirstOrder.Language.Term.relabelEquiv_symm_apply
code: /-- Relabels a term's variables along a bijection. -/
@[simps]
def relabelEquiv (g : α ≃ β) : L.Term α ≃ L.Term β 
goal: ∀ (a : L.Term β), (FirstOrder.Language.Term.relabelEquiv g).symm a = FirstOrder.Language.Term.relabel (⇑g.symm) a

full_name: FirstOrder.Language.Term.restrictVar
code: /-- Restricts a term to use only a set of the given variables. -/
def restrictVar [DecidableEq α] : ∀ (t : L.Term α) (_f : t.varFinset → β), L.Term β
  
goal: L.Term β

full_name: FirstOrder.Language.Term.restrictVarLeft
code: /-- Restricts a term to use only a set of the given variables on the left side of a sum. -/
def restrictVarLeft [DecidableEq α] {γ : Type*} :
    ∀ (t : L.Term (α ⊕ γ)) (_f : t.varFinsetLeft → β), L.Term (β ⊕ γ)
  
goal: L.Term (β ⊕ γ)

full_name: FirstOrder.Language.Constants.term
code: /-- The representation of a constant symbol as a term. -/
def Constants.term (c : L.Constants) : L.Term α 
goal: L.Term α

full_name: FirstOrder.Language.Functions.apply₁
code: /-- Applies a unary function to a term. -/
def Functions.apply₁ (f : L.Functions 1) (t : L.Term α) : L.Term α 
goal: L.Term α

full_name: FirstOrder.Language.Functions.apply₂
code: /-- Applies a binary function to two terms. -/
def Functions.apply₂ (f : L.Functions 2) (t₁ t₂ : L.Term α) : L.Term α 
goal: L.Term α

full_name: FirstOrder.Language.Term.constantsToVars
code: /-- Sends a term with constants to a term with extra variables. -/
@[simp]
def constantsToVars : L[[γ]].Term α → L.Term (γ ⊕ α)
  
goal: (L.withConstants γ).Term α → L.Term (γ ⊕ α)

full_name: FirstOrder.Language.Term.varsToConstants
code: /-- Sends a term with extra variables to a term with constants. -/
@[simp]
def varsToConstants : L.Term (γ ⊕ α) → L[[γ]].Term α
  
goal: L.Term (γ ⊕ α) → (L.withConstants γ).Term α

full_name: FirstOrder.Language.Term.constantsVarsEquiv_symm_apply
code: /-- A bijection between terms with constants and terms with extra variables. -/
@[simps]
def constantsVarsEquiv : L[[γ]].Term α ≃ L.Term (γ ⊕ α) 
goal: ∀ (a : L.Term (γ ⊕ α)), FirstOrder.Language.Term.constantsVarsEquiv.symm a = a.varsToConstants

full_name: FirstOrder.Language.Term.constantsVarsEquiv_apply
code: /-- A bijection between terms with constants and terms with extra variables. -/
@[simps]
def constantsVarsEquiv : L[[γ]].Term α ≃ L.Term (γ ⊕ α) 
goal: ∀ (a : (L.withConstants γ).Term α), FirstOrder.Language.Term.constantsVarsEquiv a = a.constantsToVars

full_name: FirstOrder.Language.Term.constantsVarsEquiv
code: /-- A bijection between terms with constants and terms with extra variables. -/
@[simps]
def constantsVarsEquiv : L[[γ]].Term α ≃ L.Term (γ ⊕ α) 
goal: (L.withConstants γ).Term α ≃ L.Term (γ ⊕ α)

full_name: FirstOrder.Language.Term.constantsVarsEquivLeft
code: /-- A bijection between terms with constants and terms with extra variables. -/
def constantsVarsEquivLeft : L[[γ]].Term (α ⊕ β) ≃ L.Term ((γ ⊕ α) ⊕ β) 
goal: (L.withConstants γ).Term (α ⊕ β) ≃ L.Term ((γ ⊕ α) ⊕ β)

full_name: FirstOrder.Language.Term.constantsVarsEquivLeft_apply
code: @[simp]
theorem constantsVarsEquivLeft_apply (t : L[[γ]].Term (α ⊕ β)) :
    constantsVarsEquivLeft t = (constantsToVars t).relabel (Equiv.sumAssoc _ _ _).symm 
goal: FirstOrder.Language.Term.constantsVarsEquivLeft t =
  FirstOrder.Language.Term.relabel (⇑(Equiv.sumAssoc γ α β).symm) t.constantsToVars

full_name: FirstOrder.Language.Term.constantsVarsEquivLeft_symm_apply
code: @[simp]
theorem constantsVarsEquivLeft_symm_apply (t : L.Term ((γ ⊕ α) ⊕ β)) :
    constantsVarsEquivLeft.symm t = varsToConstants (t.relabel (Equiv.sumAssoc _ _ _)) 
goal: FirstOrder.Language.Term.constantsVarsEquivLeft.symm t =
  (FirstOrder.Language.Term.relabel (⇑(Equiv.sumAssoc γ α β)) t).varsToConstants

full_name: FirstOrder.Language.Term.inhabitedOfVar
code: instance inhabitedOfVar [Inhabited α] : Inhabited (L.Term α) 
goal: Inhabited (L.Term α)

full_name: FirstOrder.Language.Term.inhabitedOfConstant
code: instance inhabitedOfConstant [Inhabited L.Constants] : Inhabited (L.Term α) 
goal: Inhabited (L.Term α)

full_name: FirstOrder.Language.Term.liftAt
code: /-- Raises all of the `Fin`-indexed variables of a term greater than or equal to `m` by `n'`. -/
def liftAt {n : ℕ} (n' m : ℕ) : L.Term (α ⊕ (Fin n)) → L.Term (α ⊕ (Fin (n + n'))) 
goal: L.Term (α ⊕ Fin n) → L.Term (α ⊕ Fin (n + n'))

full_name: FirstOrder.Language.Term.subst
code: /-- Substitutes the variables in a given term with terms. -/
@[simp]
def subst : L.Term α → (α → L.Term β) → L.Term β
  
goal: L.Term α → (α → L.Term β) → L.Term β

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term&__1»
code: scoped[FirstOrder] prefix:arg "&" => FirstOrder.Language.Term.var ∘ Sum.inr
goal: Lean.Macro

full_name: FirstOrder.Language.LHom.onTerm
code: /-- Maps a term's symbols along a language map. -/
@[simp]
def onTerm (φ : L →ᴸ L') : L.Term α → L'.Term α
  
goal: L.Term α → L'.Term α

full_name: FirstOrder.Language.LHom.id_onTerm
code: @[simp]
theorem id_onTerm : ((LHom.id L).onTerm : L.Term α → L.Term α) = id 
goal: (FirstOrder.Language.LHom.id L).onTerm = id

full_name: FirstOrder.Language.LHom.comp_onTerm
code: @[simp]
theorem comp_onTerm {L'' : Language} (φ : L' →ᴸ L'') (ψ : L →ᴸ L') :
    ((φ.comp ψ).onTerm : L.Term α → L''.Term α) = φ.onTerm ∘ ψ.onTerm 
goal: (φ.comp ψ).onTerm = φ.onTerm ∘ ψ.onTerm

full_name: FirstOrder.Language.Lequiv.onTerm_apply
code: /-- Maps a term's symbols along a language equivalence. -/
@[simps]
def Lequiv.onTerm (φ : L ≃ᴸ L') : L.Term α ≃ L'.Term α 
goal: ∀ (a : L.Term α), (FirstOrder.Language.Lequiv.onTerm φ) a = φ.toLHom.onTerm a

full_name: FirstOrder.Language.Lequiv.onTerm
code: /-- Maps a term's symbols along a language equivalence. -/
@[simps]
def Lequiv.onTerm (φ : L ≃ᴸ L') : L.Term α ≃ L'.Term α 
goal: L.Term α ≃ L'.Term α

full_name: FirstOrder.Language.Lequiv.onTerm_symm_apply
code: /-- Maps a term's symbols along a language equivalence. -/
@[simps]
def Lequiv.onTerm (φ : L ≃ᴸ L') : L.Term α ≃ L'.Term α 
goal: ∀ (a : L'.Term α), (FirstOrder.Language.Lequiv.onTerm φ).symm a = φ.invLHom.onTerm a

full_name: FirstOrder.Language.BoundedFormula
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: ℕ → Type (max u v u')

full_name: FirstOrder.Language.BoundedFormula.rel
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.falsum
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.all
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.imp
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.equal
code: /-- `BoundedFormula α n` is the type of formulas with free variables indexed by `α` and up to `n`
  additional free variables. -/
inductive BoundedFormula : ℕ → Type max u v u'
  | falsum {n} : BoundedFormula n
  | equal {n} (t₁ t₂ : L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | rel {n l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ (Fin n))) : BoundedFormula n
  | imp {n} (f₁ f₂ : BoundedFormula n) : BoundedFormula n
  | all {n} (f : BoundedFormula (n + 1)) : BoundedFormula n
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.Formula
code: /-- `Formula α` is the type of formulas with all free variables indexed by `α`. -/
abbrev Formula 
goal: Type (max u v u')

full_name: FirstOrder.Language.Sentence
code: /-- A sentence is a formula with no free variables. -/
abbrev Sentence 
goal: Type (max u v)

full_name: FirstOrder.Language.Theory
code: /-- A theory is a set of sentences. -/
abbrev Theory 
goal: Type (max u v)

full_name: FirstOrder.Language.Relations.boundedFormula
code: /-- Applies a relation to terms as a bounded formula. -/
def Relations.boundedFormula {l : ℕ} (R : L.Relations n) (ts : Fin n → L.Term (α ⊕ (Fin l))) :
    L.BoundedFormula α l 
goal: L.BoundedFormula α l

full_name: FirstOrder.Language.Relations.boundedFormula₁
code: /-- Applies a unary relation to a term as a bounded formula. -/
def Relations.boundedFormula₁ (r : L.Relations 1) (t : L.Term (α ⊕ (Fin n))) :
    L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.Relations.boundedFormula₂
code: /-- Applies a binary relation to two terms as a bounded formula. -/
def Relations.boundedFormula₂ (r : L.Relations 2) (t₁ t₂ : L.Term (α ⊕ (Fin n))) :
    L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.Term.bdEqual
code: /-- The equality of two terms as a bounded formula. -/
def Term.bdEqual (t₁ t₂ : L.Term (α ⊕ (Fin n))) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.Relations.formula
code: /-- Applies a relation to terms as a bounded formula. -/
def Relations.formula (R : L.Relations n) (ts : Fin n → L.Term α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.Relations.formula₁
code: /-- Applies a unary relation to a term as a formula. -/
def Relations.formula₁ (r : L.Relations 1) (t : L.Term α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.Relations.formula₂
code: /-- Applies a binary relation to two terms as a formula. -/
def Relations.formula₂ (r : L.Relations 2) (t₁ t₂ : L.Term α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.Term.equal
code: /-- The equality of two terms as a first-order formula. -/
def Term.equal (t₁ t₂ : L.Term α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.BoundedFormula.instInhabited
code: instance : Inhabited (L.BoundedFormula α n) 
goal: Inhabited (L.BoundedFormula α n)

full_name: FirstOrder.Language.BoundedFormula.instBot
code: instance : Bot (L.BoundedFormula α n) 
goal: Bot (L.BoundedFormula α n)

full_name: FirstOrder.Language.BoundedFormula.not
code: /-- The negation of a bounded formula is also a bounded formula. -/
@[match_pattern]
protected def not (φ : L.BoundedFormula α n) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.ex
code: /-- Puts an `∃` quantifier on a bounded formula. -/
@[match_pattern]
protected def ex (φ : L.BoundedFormula α (n + 1)) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.instTop
code: instance : Top (L.BoundedFormula α n) 
goal: Top (L.BoundedFormula α n)

full_name: FirstOrder.Language.BoundedFormula.instInf
code: instance : Inf (L.BoundedFormula α n) 
goal: Inf (L.BoundedFormula α n)

full_name: FirstOrder.Language.BoundedFormula.instSup
code: instance : Sup (L.BoundedFormula α n) 
goal: Sup (L.BoundedFormula α n)

full_name: FirstOrder.Language.BoundedFormula.iff
code: /-- The biimplication between two bounded formulas. -/
protected def iff (φ ψ : L.BoundedFormula α n) 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.freeVarFinset
code: /-- The `Finset` of variables used in a given formula. -/
@[simp]
def freeVarFinset [DecidableEq α] : ∀ {n}, L.BoundedFormula α n → Finset α
  
goal: L.BoundedFormula α n → Finset α

full_name: FirstOrder.Language.BoundedFormula.castLE
code: /-- Casts `L.BoundedFormula α m` as `L.BoundedFormula α n`, where `m ≤ n`. -/
@[simp]
def castLE : ∀ {m n : ℕ} (_h : m ≤ n), L.BoundedFormula α m → L.BoundedFormula α n
  
goal: L.BoundedFormula α m → L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.castLE_rfl
code: @[simp]
theorem castLE_rfl {n} (h : n ≤ n) (φ : L.BoundedFormula α n) : φ.castLE h = φ 
goal: FirstOrder.Language.BoundedFormula.castLE h φ = φ

full_name: FirstOrder.Language.BoundedFormula.castLE_castLE
code: @[simp]
theorem castLE_castLE {k m n} (km : k ≤ m) (mn : m ≤ n) (φ : L.BoundedFormula α k) :
    (φ.castLE km).castLE mn = φ.castLE (km.trans mn) 
goal: FirstOrder.Language.BoundedFormula.castLE mn (FirstOrder.Language.BoundedFormula.castLE km φ) =
  FirstOrder.Language.BoundedFormula.castLE ⋯ φ

full_name: FirstOrder.Language.BoundedFormula.castLE_comp_castLE
code: @[simp]
theorem castLE_comp_castLE {k m n} (km : k ≤ m) (mn : m ≤ n) :
    (BoundedFormula.castLE mn ∘ BoundedFormula.castLE km :
        L.BoundedFormula α k → L.BoundedFormula α n) =
      BoundedFormula.castLE (km.trans mn) 
goal: FirstOrder.Language.BoundedFormula.castLE mn ∘ FirstOrder.Language.BoundedFormula.castLE km =
  FirstOrder.Language.BoundedFormula.castLE ⋯

full_name: FirstOrder.Language.BoundedFormula.restrictFreeVar
code: /-- Restricts a bounded formula to only use a particular set of free variables. -/
def restrictFreeVar [DecidableEq α] :
    ∀ {n : ℕ} (φ : L.BoundedFormula α n) (_f : φ.freeVarFinset → β), L.BoundedFormula β n
  
goal: L.BoundedFormula β n

full_name: FirstOrder.Language.BoundedFormula.alls
code: /-- Places universal quantifiers on all extra variables of a bounded formula. -/
def alls : ∀ {n}, L.BoundedFormula α n → L.Formula α
  
goal: L.BoundedFormula α n → L.Formula α

full_name: FirstOrder.Language.BoundedFormula.exs
code: /-- Places existential quantifiers on all extra variables of a bounded formula. -/
def exs : ∀ {n}, L.BoundedFormula α n → L.Formula α
  
goal: L.BoundedFormula α n → L.Formula α

full_name: FirstOrder.Language.BoundedFormula.mapTermRel
code: /-- Maps bounded formulas along a map of terms and a map of relations. -/
def mapTermRel {g : ℕ → ℕ} (ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin (g n))))
    (fr : ∀ n, L.Relations n → L'.Relations n)
    (h : ∀ n, L'.BoundedFormula β (g (n + 1)) → L'.BoundedFormula β (g n + 1)) :
    ∀ {n}, L.BoundedFormula α n → L'.BoundedFormula β (g n)
  
goal: L.BoundedFormula α n → L'.BoundedFormula β (g n)

full_name: FirstOrder.Language.BoundedFormula.liftAt
code: /-- Raises all of the `Fin`-indexed variables of a formula greater than or equal to `m` by `n'`. -/
def liftAt : ∀ {n : ℕ} (n' _m : ℕ), L.BoundedFormula α n → L.BoundedFormula α (n + n') 
goal: L.BoundedFormula α n → L.BoundedFormula α (n + n')

full_name: FirstOrder.Language.BoundedFormula.mapTermRel_mapTermRel
code: @[simp]
theorem mapTermRel_mapTermRel {L'' : Language}
    (ft : ∀ n, L.Term (α ⊕ (Fin n)) → L'.Term (β ⊕ (Fin n)))
    (fr : ∀ n, L.Relations n → L'.Relations n)
    (ft' : ∀ n, L'.Term (β ⊕ Fin n) → L''.Term (γ ⊕ (Fin n)))
    (fr' : ∀ n, L'.Relations n → L''.Relations n) {n} (φ : L.BoundedFormula α n) :
    ((φ.mapTermRel ft fr fun _ => id).mapTermRel ft' fr' fun _ => id) =
      φ.mapTermRel (fun _ => ft' _ ∘ ft _) (fun _ => fr' _ ∘ fr _) fun _ => id 
goal: FirstOrder.Language.BoundedFormula.mapTermRel ft' fr' (fun x => id)
    (FirstOrder.Language.BoundedFormula.mapTermRel ft fr (fun x => id) φ) =
  FirstOrder.Language.BoundedFormula.mapTermRel (fun x => ft' x ∘ ft x) (fun x => fr' x ∘ fr x) (fun x => id) φ

full_name: FirstOrder.Language.BoundedFormula.mapTermRel_id_id_id
code: @[simp]
theorem mapTermRel_id_id_id {n} (φ : L.BoundedFormula α n) :
    (φ.mapTermRel (fun _ => id) (fun _ => id) fun _ => id) = φ 
goal: FirstOrder.Language.BoundedFormula.mapTermRel (fun x => id) (fun x => id) (fun x => id) φ = φ

full_name: FirstOrder.Language.BoundedFormula.mapTermRelEquiv
code: /-- An equivalence of bounded formulas given by an equivalence of terms and an equivalence of
relations. -/
@[simps]
def mapTermRelEquiv (ft : ∀ n, L.Term (α ⊕ (Fin n)) ≃ L'.Term (β ⊕ (Fin n)))
    (fr : ∀ n, L.Relations n ≃ L'.Relations n) {n} : L.BoundedFormula α n ≃ L'.BoundedFormula β n 
goal: L.BoundedFormula α n ≃ L'.BoundedFormula β n

full_name: FirstOrder.Language.BoundedFormula.mapTermRelEquiv_symm_apply
code: /-- An equivalence of bounded formulas given by an equivalence of terms and an equivalence of
relations. -/
@[simps]
def mapTermRelEquiv (ft : ∀ n, L.Term (α ⊕ (Fin n)) ≃ L'.Term (β ⊕ (Fin n)))
    (fr : ∀ n, L.Relations n ≃ L'.Relations n) {n} : L.BoundedFormula α n ≃ L'.BoundedFormula β n 
goal: ∀ (a : L'.BoundedFormula β n),
  (FirstOrder.Language.BoundedFormula.mapTermRelEquiv ft fr).symm a =
    FirstOrder.Language.BoundedFormula.mapTermRel (fun n => ⇑(ft n).symm) (fun n => ⇑(fr n).symm) (fun x => id) a

full_name: FirstOrder.Language.BoundedFormula.mapTermRelEquiv_apply
code: /-- An equivalence of bounded formulas given by an equivalence of terms and an equivalence of
relations. -/
@[simps]
def mapTermRelEquiv (ft : ∀ n, L.Term (α ⊕ (Fin n)) ≃ L'.Term (β ⊕ (Fin n)))
    (fr : ∀ n, L.Relations n ≃ L'.Relations n) {n} : L.BoundedFormula α n ≃ L'.BoundedFormula β n 
goal: ∀ (a : L.BoundedFormula α n),
  (FirstOrder.Language.BoundedFormula.mapTermRelEquiv ft fr) a =
    FirstOrder.Language.BoundedFormula.mapTermRel (fun n => ⇑(ft n)) (fun n => ⇑(fr n)) (fun x => id) a

full_name: FirstOrder.Language.BoundedFormula.relabelAux
code: /-- A function to help relabel the variables in bounded formulas. -/
def relabelAux (g : α → β ⊕ (Fin n)) (k : ℕ) : α ⊕ (Fin k) → β ⊕ (Fin (n + k)) 
goal: α ⊕ Fin k → β ⊕ Fin (n + k)

full_name: FirstOrder.Language.BoundedFormula.sum_elim_comp_relabelAux
code: @[simp]
theorem sum_elim_comp_relabelAux {m : ℕ} {g : α → β ⊕ (Fin n)} {v : β → M}
    {xs : Fin (n + m) → M} : Sum.elim v xs ∘ relabelAux g m =
    Sum.elim (Sum.elim v (xs ∘ castAdd m) ∘ g) (xs ∘ natAdd n) 
goal: Sum.elim v xs ∘ FirstOrder.Language.BoundedFormula.relabelAux g m =
  Sum.elim (Sum.elim v (xs ∘ Fin.castAdd m) ∘ g) (xs ∘ Fin.natAdd n)

full_name: FirstOrder.Language.BoundedFormula.relabelAux_sum_inl
code: @[simp]
theorem relabelAux_sum_inl (k : ℕ) :
    relabelAux (Sum.inl : α → α ⊕ (Fin n)) k = Sum.map id (natAdd n) 
goal: FirstOrder.Language.BoundedFormula.relabelAux Sum.inl k = Sum.map id (Fin.natAdd n)

full_name: FirstOrder.Language.BoundedFormula.relabel
code: /-- Relabels a bounded formula's variables along a particular function. -/
def relabel (g : α → β ⊕ (Fin n)) {k} (φ : L.BoundedFormula α k) : L.BoundedFormula β (n + k) 
goal: L.BoundedFormula β (n + k)

full_name: FirstOrder.Language.BoundedFormula.relabelEquiv
code: /-- Relabels a bounded formula's free variables along a bijection. -/
def relabelEquiv (g : α ≃ β) {k} : L.BoundedFormula α k ≃ L.BoundedFormula β k 
goal: L.BoundedFormula α k ≃ L.BoundedFormula β k

full_name: FirstOrder.Language.BoundedFormula.relabel_falsum
code: @[simp]
theorem relabel_falsum (g : α → β ⊕ (Fin n)) {k} :
    (falsum : L.BoundedFormula α k).relabel g = falsum 
goal: FirstOrder.Language.BoundedFormula.relabel g FirstOrder.Language.BoundedFormula.falsum =
  FirstOrder.Language.BoundedFormula.falsum

full_name: FirstOrder.Language.BoundedFormula.relabel_bot
code: @[simp]
theorem relabel_bot (g : α → β ⊕ (Fin n)) {k} : (⊥ : L.BoundedFormula α k).relabel g = ⊥ 
goal: FirstOrder.Language.BoundedFormula.relabel g ⊥ = ⊥

full_name: FirstOrder.Language.BoundedFormula.relabel_imp
code: @[simp]
theorem relabel_imp (g : α → β ⊕ (Fin n)) {k} (φ ψ : L.BoundedFormula α k) :
    (φ.imp ψ).relabel g = (φ.relabel g).imp (ψ.relabel g) 
goal: FirstOrder.Language.BoundedFormula.relabel g (φ.imp ψ) =
  (FirstOrder.Language.BoundedFormula.relabel g φ).imp (FirstOrder.Language.BoundedFormula.relabel g ψ)

full_name: FirstOrder.Language.BoundedFormula.relabel_not
code: @[simp]
theorem relabel_not (g : α → β ⊕ (Fin n)) {k} (φ : L.BoundedFormula α k) :
    φ.not.relabel g = (φ.relabel g).not 
goal: FirstOrder.Language.BoundedFormula.relabel g φ.not = (FirstOrder.Language.BoundedFormula.relabel g φ).not

full_name: FirstOrder.Language.BoundedFormula.relabel_all
code: @[simp]
theorem relabel_all (g : α → β ⊕ (Fin n)) {k} (φ : L.BoundedFormula α (k + 1)) :
    φ.all.relabel g = (φ.relabel g).all 
goal: FirstOrder.Language.BoundedFormula.relabel g φ.all = (FirstOrder.Language.BoundedFormula.relabel g φ).all

full_name: FirstOrder.Language.BoundedFormula.relabel_ex
code: @[simp]
theorem relabel_ex (g : α → β ⊕ (Fin n)) {k} (φ : L.BoundedFormula α (k + 1)) :
    φ.ex.relabel g = (φ.relabel g).ex 
goal: FirstOrder.Language.BoundedFormula.relabel g φ.ex = (FirstOrder.Language.BoundedFormula.relabel g φ).ex

full_name: FirstOrder.Language.BoundedFormula.relabel_sum_inl
code: @[simp]
theorem relabel_sum_inl (φ : L.BoundedFormula α n) :
    (φ.relabel Sum.inl : L.BoundedFormula α (0 + n)) = φ.castLE (ge_of_eq (zero_add n)) 
goal: FirstOrder.Language.BoundedFormula.relabel Sum.inl φ = FirstOrder.Language.BoundedFormula.castLE ⋯ φ

full_name: FirstOrder.Language.BoundedFormula.subst
code: /-- Substitutes the variables in a given formula with terms. -/
def subst {n : ℕ} (φ : L.BoundedFormula α n) (f : α → L.Term β) : L.BoundedFormula β n 
goal: L.BoundedFormula β n

full_name: FirstOrder.Language.BoundedFormula.constantsVarsEquiv
code: /-- A bijection sending formulas with constants to formulas with extra variables. -/
def constantsVarsEquiv : L[[γ]].BoundedFormula α n ≃ L.BoundedFormula (γ ⊕ α) n 
goal: (L.withConstants γ).BoundedFormula α n ≃ L.BoundedFormula (γ ⊕ α) n

full_name: FirstOrder.Language.BoundedFormula.toFormula
code: /-- Turns the extra variables of a bounded formula into free variables. -/
@[simp]
def toFormula : ∀ {n : ℕ}, L.BoundedFormula α n → L.Formula (α ⊕ (Fin n))
  
goal: L.BoundedFormula α n → L.Formula (α ⊕ Fin n)

full_name: FirstOrder.Language.BoundedFormula.iSup
code: /-- take the disjunction of a finite set of formulas -/
noncomputable def iSup (s : Finset β) (f : β → L.BoundedFormula α n) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.BoundedFormula.iInf
code: /-- take the conjunction of a finite set of formulas -/
noncomputable def iInf (s : Finset β) (f : β → L.BoundedFormula α n) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.LHom.onBoundedFormula
code: /-- Maps a bounded formula's symbols along a language map. -/
@[simp]
def onBoundedFormula (g : L →ᴸ L') : ∀ {k : ℕ}, L.BoundedFormula α k → L'.BoundedFormula α k
  
goal: L.BoundedFormula α k → L'.BoundedFormula α k

full_name: FirstOrder.Language.LHom.id_onBoundedFormula
code: @[simp]
theorem id_onBoundedFormula :
    ((LHom.id L).onBoundedFormula : L.BoundedFormula α n → L.BoundedFormula α n) = id 
goal: (FirstOrder.Language.LHom.id L).onBoundedFormula = id

full_name: FirstOrder.Language.LHom.comp_onBoundedFormula
code: @[simp]
theorem comp_onBoundedFormula {L'' : Language} (φ : L' →ᴸ L'') (ψ : L →ᴸ L') :
    ((φ.comp ψ).onBoundedFormula : L.BoundedFormula α n → L''.BoundedFormula α n) =
      φ.onBoundedFormula ∘ ψ.onBoundedFormula 
goal: (φ.comp ψ).onBoundedFormula = φ.onBoundedFormula ∘ ψ.onBoundedFormula

full_name: FirstOrder.Language.LHom.onFormula
code: /-- Maps a formula's symbols along a language map. -/
def onFormula (g : L →ᴸ L') : L.Formula α → L'.Formula α 
goal: L.Formula α → L'.Formula α

full_name: FirstOrder.Language.LHom.onSentence
code: /-- Maps a sentence's symbols along a language map. -/
def onSentence (g : L →ᴸ L') : L.Sentence → L'.Sentence 
goal: L.Sentence → L'.Sentence

full_name: FirstOrder.Language.LHom.onTheory
code: /-- Maps a theory's symbols along a language map. -/
def onTheory (g : L →ᴸ L') (T : L.Theory) : L'.Theory 
goal: L'.Theory

full_name: FirstOrder.Language.LHom.mem_onTheory
code: @[simp]
theorem mem_onTheory {g : L →ᴸ L'} {T : L.Theory} {φ : L'.Sentence} :
    φ ∈ g.onTheory T ↔ ∃ φ₀, φ₀ ∈ T ∧ g.onSentence φ₀ = φ 
goal: φ ∈ g.onTheory T ↔ ∃ φ₀ ∈ T, g.onSentence φ₀ = φ

full_name: FirstOrder.Language.LEquiv.onBoundedFormula
code: /-- Maps a bounded formula's symbols along a language equivalence. -/
@[simps]
def onBoundedFormula (φ : L ≃ᴸ L') : L.BoundedFormula α n ≃ L'.BoundedFormula α n 
goal: L.BoundedFormula α n ≃ L'.BoundedFormula α n

full_name: FirstOrder.Language.LEquiv.onBoundedFormula_symm_apply
code: /-- Maps a bounded formula's symbols along a language equivalence. -/
@[simps]
def onBoundedFormula (φ : L ≃ᴸ L') : L.BoundedFormula α n ≃ L'.BoundedFormula α n 
goal: ∀ (a : L'.BoundedFormula α n), φ.onBoundedFormula.symm a = φ.invLHom.onBoundedFormula a

full_name: FirstOrder.Language.LEquiv.onBoundedFormula_apply
code: /-- Maps a bounded formula's symbols along a language equivalence. -/
@[simps]
def onBoundedFormula (φ : L ≃ᴸ L') : L.BoundedFormula α n ≃ L'.BoundedFormula α n 
goal: ∀ (a : L.BoundedFormula α n), φ.onBoundedFormula a = φ.toLHom.onBoundedFormula a

full_name: FirstOrder.Language.LEquiv.onBoundedFormula_symm
code: theorem onBoundedFormula_symm (φ : L ≃ᴸ L') :
    (φ.onBoundedFormula.symm : L'.BoundedFormula α n ≃ L.BoundedFormula α n) =
      φ.symm.onBoundedFormula 
goal: φ.onBoundedFormula.symm = φ.symm.onBoundedFormula

full_name: FirstOrder.Language.LEquiv.onFormula
code: /-- Maps a formula's symbols along a language equivalence. -/
def onFormula (φ : L ≃ᴸ L') : L.Formula α ≃ L'.Formula α 
goal: L.Formula α ≃ L'.Formula α

full_name: FirstOrder.Language.LEquiv.onFormula_apply
code: @[simp]
theorem onFormula_apply (φ : L ≃ᴸ L') :
    (φ.onFormula : L.Formula α → L'.Formula α) = φ.toLHom.onFormula 
goal: ⇑φ.onFormula = φ.toLHom.onFormula

full_name: FirstOrder.Language.LEquiv.onFormula_symm
code: @[simp]
theorem onFormula_symm (φ : L ≃ᴸ L') :
    (φ.onFormula.symm : L'.Formula α ≃ L.Formula α) = φ.symm.onFormula 
goal: φ.onFormula.symm = φ.symm.onFormula

full_name: FirstOrder.Language.LEquiv.onSentence
code: /-- Maps a sentence's symbols along a language equivalence. -/
@[simps!] -- Porting note: add `!` to `simps`
def onSentence (φ : L ≃ᴸ L') : L.Sentence ≃ L'.Sentence 
goal: L.Sentence ≃ L'.Sentence

full_name: FirstOrder.Language.LEquiv.onSentence_symm_apply
code: /-- Maps a sentence's symbols along a language equivalence. -/
@[simps!] -- Porting note: add `!` to `simps`
def onSentence (φ : L ≃ᴸ L') : L.Sentence ≃ L'.Sentence 
goal: ∀ (a : L'.BoundedFormula Empty 0), φ.onSentence.symm a = φ.invLHom.onBoundedFormula a

full_name: FirstOrder.Language.LEquiv.onSentence_apply
code: /-- Maps a sentence's symbols along a language equivalence. -/
@[simps!] -- Porting note: add `!` to `simps`
def onSentence (φ : L ≃ᴸ L') : L.Sentence ≃ L'.Sentence 
goal: ∀ (a : L.BoundedFormula Empty 0), φ.onSentence a = φ.toLHom.onBoundedFormula a

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_Term_bdEqual_1
code: scoped[FirstOrder] infixl:88 " =' " => FirstOrder.Language.Term.bdEqual
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term_='__1»
code: scoped[FirstOrder] infixl:88 " =' " => FirstOrder.Language.Term.bdEqual
goal: Lean.Macro

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_BoundedFormula_imp_1
code: scoped[FirstOrder] infixr:62 " ⟹ " => FirstOrder.Language.BoundedFormula.imp
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term_⟹__1»
code: scoped[FirstOrder] infixr:62 " ⟹ " => FirstOrder.Language.BoundedFormula.imp
goal: Lean.Macro

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_BoundedFormula_all_1
code: scoped[FirstOrder] prefix:110 "∀'" => FirstOrder.Language.BoundedFormula.all
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term∀'__1»
code: scoped[FirstOrder] prefix:110 "∀'" => FirstOrder.Language.BoundedFormula.all
goal: Lean.Macro

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term∼__1»
code: scoped[FirstOrder] prefix:arg "∼" => FirstOrder.Language.BoundedFormula.not
goal: Lean.Macro

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_BoundedFormula_not_1
code: scoped[FirstOrder] prefix:arg "∼" => FirstOrder.Language.BoundedFormula.not
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_BoundedFormula_iff_1
code: scoped[FirstOrder] infixl:61 " ⇔ " => FirstOrder.Language.BoundedFormula.iff
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term_⇔__1»
code: scoped[FirstOrder] infixl:61 " ⇔ " => FirstOrder.Language.BoundedFormula.iff
goal: Lean.Macro

full_name: FirstOrder._aux_Mathlib_ModelTheory_Syntax___unexpand_FirstOrder_Language_BoundedFormula_ex_1
code: scoped[FirstOrder] prefix:110 "∃'" => FirstOrder.Language.BoundedFormula.ex
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.«_aux_Mathlib_ModelTheory_Syntax___macroRules_FirstOrder_term∃'__1»
code: scoped[FirstOrder] prefix:110 "∃'" => FirstOrder.Language.BoundedFormula.ex
goal: Lean.Macro

full_name: FirstOrder.Language.Formula.relabel
code: /-- Relabels a formula's variables along a particular function. -/
def relabel (g : α → β) : L.Formula α → L.Formula β 
goal: L.Formula α → L.Formula β

full_name: FirstOrder.Language.Formula.graph
code: /-- The graph of a function as a first-order formula. -/
def graph (f : L.Functions n) : L.Formula (Fin (n + 1)) 
goal: L.Formula (Fin (n + 1))

full_name: FirstOrder.Language.Formula.not
code: /-- The negation of a formula. -/
protected nonrec abbrev not (φ : L.Formula α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.Formula.imp
code: /-- The implication between formulas, as a formula. -/
protected abbrev imp : L.Formula α → L.Formula α → L.Formula α 
goal: L.Formula α → L.Formula α → L.Formula α

full_name: FirstOrder.Language.Formula.iAlls
code: /-- Given a map `f : α → β ⊕ γ`, `iAlls f φ` transforms a `L.Formula α`
into a `L.Formula β` by renaming variables with the map `f` and then universally
quantifying over all variables `Sum.inr _`. -/
noncomputable def iAlls [Finite γ] (f : α → β ⊕ γ)
    (φ : L.Formula α) : L.Formula β 
goal: L.Formula β

full_name: FirstOrder.Language.Formula.iExs
code: /-- Given a map `f : α → β ⊕ γ`, `iExs f φ` transforms a `L.Formula α`
into a `L.Formula β` by renaming variables with the map `f` and then universally
quantifying over all variables `Sum.inr _`. -/
noncomputable def iExs [Finite γ] (f : α → β ⊕ γ)
    (φ : L.Formula α) : L.Formula β 
goal: L.Formula β

full_name: FirstOrder.Language.Formula.iff
code: /-- The biimplication between formulas, as a formula. -/
protected nonrec abbrev iff (φ ψ : L.Formula α) : L.Formula α 
goal: L.Formula α

full_name: FirstOrder.Language.Formula.equivSentence
code: /-- A bijection sending formulas to sentences with constants. -/
def equivSentence : L.Formula α ≃ L[[α]].Sentence 
goal: L.Formula α ≃ (L.withConstants α).Sentence

full_name: FirstOrder.Language.Formula.equivSentence_not
code: theorem equivSentence_not (φ : L.Formula α) : equivSentence φ.not = (equivSentence φ).not 
goal: FirstOrder.Language.Formula.equivSentence φ.not =
  FirstOrder.Language.Formula.not (FirstOrder.Language.Formula.equivSentence φ)

full_name: FirstOrder.Language.Formula.equivSentence_inf
code: theorem equivSentence_inf (φ ψ : L.Formula α) :
    equivSentence (φ ⊓ ψ) = equivSentence φ ⊓ equivSentence ψ 
goal: FirstOrder.Language.Formula.equivSentence (φ ⊓ ψ) =
  FirstOrder.Language.Formula.equivSentence φ ⊓ FirstOrder.Language.Formula.equivSentence ψ

full_name: FirstOrder.Language.Relations.reflexive
code: /-- The sentence indicating that a basic relation symbol is reflexive. -/
protected def reflexive : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Relations.irreflexive
code: /-- The sentence indicating that a basic relation symbol is irreflexive. -/
protected def irreflexive : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Relations.symmetric
code: /-- The sentence indicating that a basic relation symbol is symmetric. -/
protected def symmetric : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Relations.antisymmetric
code: /-- The sentence indicating that a basic relation symbol is antisymmetric. -/
protected def antisymmetric : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Relations.transitive
code: /-- The sentence indicating that a basic relation symbol is transitive. -/
protected def transitive : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Relations.total
code: /-- The sentence indicating that a basic relation symbol is total. -/
protected def total : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.Sentence.cardGe
code: /-- A sentence indicating that a structure has `n` distinct elements. -/
protected def Sentence.cardGe (n : ℕ) : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.infiniteTheory
code: /-- A theory indicating that a structure is infinite. -/
def infiniteTheory : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.nonemptyTheory
code: /-- A theory that indicates a structure is nonempty. -/
def nonemptyTheory : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.distinctConstantsTheory
code: /-- A theory indicating that each of a set of constants is distinct. -/
def distinctConstantsTheory (s : Set α) : L[[α]].Theory 
goal: (L.withConstants α).Theory

full_name: FirstOrder.Language.distinctConstantsTheory_mono
code: theorem distinctConstantsTheory_mono {s t : Set α} (h : s ⊆ t) :
    L.distinctConstantsTheory s ⊆ L.distinctConstantsTheory t 
goal: L.distinctConstantsTheory s ⊆ L.distinctConstantsTheory t

full_name: FirstOrder.Language.monotone_distinctConstantsTheory
code: theorem monotone_distinctConstantsTheory :
    Monotone (L.distinctConstantsTheory : Set α → L[[α]].Theory) 
goal: Monotone L.distinctConstantsTheory

full_name: FirstOrder.Language.directed_distinctConstantsTheory
code: theorem directed_distinctConstantsTheory :
    Directed (· ⊆ ·) (L.distinctConstantsTheory : Set α → L[[α]].Theory) 
goal: Directed (fun x x_1 => x ⊆ x_1) L.distinctConstantsTheory

full_name: FirstOrder.Language.distinctConstantsTheory_eq_iUnion
code: theorem distinctConstantsTheory_eq_iUnion (s : Set α) :
    L.distinctConstantsTheory s =
      ⋃ t : Finset s,
        L.distinctConstantsTheory (t.map (Function.Embedding.subtype fun x => x ∈ s)) 
goal: L.distinctConstantsTheory s = ⋃ t, L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) t)