structure LO.FirstOrder.Semiterm.Operator (L : Language) (n : ℕ) : Type u_1

• term : ClosedSemiterm L n

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.Const (L : Language) : Type u

Equations

• LO.FirstOrder.Semiterm.Const L = LO.FirstOrder.Semiterm.Operator L 0

def LO.FirstOrder.Semiterm.fn {L : Language} {k : ℕ} (f : L.Func k) : Operator L k

Equations

• LO.FirstOrder.Semiterm.fn f = { term := LO.FirstOrder.Semiterm.func f fun (x : Fin k) => LO.FirstOrder.Semiterm.bvar x }

def LO.FirstOrder.Semiterm.Operator.equiv {L : Language} {n : ℕ} : Operator L n ≃ ClosedSemiterm L n

Equations

• LO.FirstOrder.Semiterm.Operator.equiv = { toFun := LO.FirstOrder.Semiterm.Operator.term, invFun := LO.FirstOrder.Semiterm.Operator.mk, left_inv := ⋯, right_inv := ⋯ }

def LO.FirstOrder.Semiterm.Operator.operator {L : Language} {ξ : Type u_2} {n arity : ℕ} (o : Operator L arity) (v : Fin arity → Semiterm L ξ n) : Semiterm L ξ n

Equations

• o.operator v = (LO.FirstOrder.Rew.subst v) (LO.FirstOrder.Rew.emb o.term)

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.Operator.const {L : Language} {ξ : Type u_2} {n : ℕ} (c : Const L) : Semiterm L ξ n

Equations

• ↑c = LO.FirstOrder.Semiterm.Operator.operator c ![]

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instCoeConst {L : Language} {ξ : Type u_2} {n : ℕ} : Coe (Const L) (Semiterm L ξ n)

Equations

• LO.FirstOrder.Semiterm.Operator.instCoeConst = { coe := LO.FirstOrder.Semiterm.Operator.const }

def LO.FirstOrder.Semiterm.Operator.comp {L : Language} {k l : ℕ} (o : Operator L k) (w : Fin k → Operator L l) : Operator L l

Equations

• o.comp w = { term := o.operator fun (x : Fin k) => (w x).term }

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.operator_comp {L : Language} {k l : ℕ} {ξ : Type u_1} {n : ℕ} (o : Operator L k) (w : Fin k → Operator L l) (v : Fin l → Semiterm L ξ n) : (o.comp w).operator v = o.operator fun (x : Fin k) => (w x).operator v

def LO.FirstOrder.Semiterm.Operator.bvar {L : Language} {n : ℕ} (x : Fin n) : Operator L n

Equations

• LO.FirstOrder.Semiterm.Operator.bvar x = { term := LO.FirstOrder.Semiterm.bvar x }

theorem LO.FirstOrder.Semiterm.Operator.operator_bvar {L : Language} {k : ℕ} {ξ : Type u_1} {n : ℕ} (x : Fin k) (v : Fin k → Semiterm L ξ n) : (bvar x).operator v = v x

theorem LO.FirstOrder.Semiterm.Operator.bv_operator {L : Language} {ξ : Type u_1} {n k : ℕ} (o : Operator L k) (v : Fin k → Semiterm L ξ (n + 1)) : (o.operator v).bv = (bv o.term).biUnion fun (i : Fin k) => (v i).bv

theorem LO.FirstOrder.Semiterm.Operator.positive_operator_iff {L : Language} {ξ : Type u_1} {n k : ℕ} {o : Operator L k} {v : Fin k → Semiterm L ξ (n + 1)} : (o.operator v).Positive ↔ ∀ i ∈ bv o.term, (v i).Positive

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.positive_const {L : Language} {ξ : Type u_1} {n : ℕ} (c : Const L) : (↑c).Positive

def LO.FirstOrder.Semiterm.Operator.foldr {L : Language} {k : ℕ} (f : Operator L 2) (z : Operator L k) : List (Operator L k) → Operator L k

Equations

• f.foldr z [] = z
• f.foldr z (o :: os) = f.comp ![f.foldr z os, o]

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.foldr_nil {L : Language} {k : ℕ} (f : Operator L 2) (z : Operator L k) : f.foldr z [] = z

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.operator_foldr_cons {L : Language} {k : ℕ} {ξ : Type u_1} {n : ℕ} (f : Operator L 2) (z o : Operator L k) (os : List (Operator L k)) (v : Fin k → Semiterm L ξ n) : (f.foldr z (o :: os)).operator v = f.operator ![(f.foldr z os).operator v, o.operator v]

def LO.FirstOrder.Semiterm.Operator.iterr {L : Language} (f : Operator L 2) (z : Const L) (n : ℕ) : Operator L n

Equations

• f.iterr z 0 = z
• f.iterr z n.succ = f.foldr (LO.FirstOrder.Semiterm.Operator.bvar 0) (List.ofFn fun (x : Fin n) => LO.FirstOrder.Semiterm.Operator.bvar x.succ)

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.iterr_zero {L : Language} (f : Operator L 2) (z : Const L) : f.iterr z 0 = z

class LO.FirstOrder.Semiterm.Operator.Zero (L : Language) : Type u_1

• zero : Const L

class LO.FirstOrder.Semiterm.Operator.One (L : Language) : Type u_1

• one : Const L

class LO.FirstOrder.Semiterm.Operator.Add (L : Language) : Type u_1

• add : Operator L 2

class LO.FirstOrder.Semiterm.Operator.Mul (L : Language) : Type u_1

• mul : Operator L 2

class LO.FirstOrder.Semiterm.Operator.Exp (L : Language) : Type u_1

• exp : Operator L 1

class LO.FirstOrder.Semiterm.Operator.Sub (L : Language) : Type u_1

• sub : Operator L 2

class LO.FirstOrder.Semiterm.Operator.Div (L : Language) : Type u_1

• div : Operator L 2

class LO.FirstOrder.Semiterm.Operator.Star (L : Language) : Type u_1

• star : Const L

class LO.FirstOrder.Semiterm.Operator.GödelNumber (L : Language) (α : Type u_1) : Type (max u_1 u_2)

• gödelNumber : α → Const L

def LO.FirstOrder.Semiterm.Operator.«termOp(0)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiterm.Operator.«termOp(0)» = Lean.ParserDescr.node `LO.FirstOrder.Semiterm.Operator.«termOp(0)» 1024 (Lean.ParserDescr.symbol "op(0)")

def LO.FirstOrder.Semiterm.Operator.«termOp(0)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiterm.Operator.«termOp(1)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiterm.Operator.«termOp(1)» = Lean.ParserDescr.node `LO.FirstOrder.Semiterm.Operator.«termOp(1)» 1024 (Lean.ParserDescr.symbol "op(1)")

def LO.FirstOrder.Semiterm.Operator.«termOp(1)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiterm.Operator.«termOp(+)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiterm.Operator.«termOp(+)» = Lean.ParserDescr.node `LO.FirstOrder.Semiterm.Operator.«termOp(+)» 1024 (Lean.ParserDescr.symbol "op(+)")

def LO.FirstOrder.Semiterm.Operator.«termOp(+)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiterm.Operator.«termOp(*)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiterm.Operator.«termOp(*)» = Lean.ParserDescr.node `LO.FirstOrder.Semiterm.Operator.«termOp(*)» 1024 (Lean.ParserDescr.symbol "op(*)")

def LO.FirstOrder.Semiterm.Operator.«termOp(*)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instZeroOfZero {L : Language} [L.Zero] : Operator.Zero L

Equations

• LO.FirstOrder.Semiterm.Operator.instZeroOfZero = { zero := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.Zero.zero ![] } }

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instOneOfOne {L : Language} [L.One] : Operator.One L

Equations

• LO.FirstOrder.Semiterm.Operator.instOneOfOne = { one := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.One.one ![] } }

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instAddOfAdd {L : Language} [L.Add] : Operator.Add L

Equations

• LO.FirstOrder.Semiterm.Operator.instAddOfAdd = { add := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.Add.add LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instMulOfMul {L : Language} [L.Mul] : Operator.Mul L

Equations

• LO.FirstOrder.Semiterm.Operator.instMulOfMul = { mul := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.Mul.mul LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instExpOfExp {L : Language} [L.Exp] : Operator.Exp L

Equations

• LO.FirstOrder.Semiterm.Operator.instExpOfExp = { exp := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.Exp.exp LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.instStarOfStar {L : Language} [L.Star] : Operator.Star L

Equations

• LO.FirstOrder.Semiterm.Operator.instStarOfStar = { star := { term := LO.FirstOrder.Semiterm.func LO.FirstOrder.Language.Star.star ![] } }

theorem LO.FirstOrder.Semiterm.Operator.Zero.term_eq {L : Language} [L.Zero] : op(0).term = func Language.Zero.zero ![]

theorem LO.FirstOrder.Semiterm.Operator.One.term_eq {L : Language} [L.One] : op(1).term = func Language.One.one ![]

theorem LO.FirstOrder.Semiterm.Operator.Add.term_eq {L : Language} [L.Add] : op(+).term = func Language.Add.add Semiterm.bvar

theorem LO.FirstOrder.Semiterm.Operator.Mul.term_eq {L : Language} [L.Mul] : op(*).term = func Language.Mul.mul Semiterm.bvar

theorem LO.FirstOrder.Semiterm.Operator.Exp.term_eq {L : Language} [L.Exp] : exp.term = func Language.Exp.exp Semiterm.bvar

theorem LO.FirstOrder.Semiterm.Operator.Star.term_eq {L : Language} [L.Star] : star.term = func Language.Star.star ![]

def LO.FirstOrder.Semiterm.Operator.numeral (L : Language) [Operator.Zero L] [Operator.One L] [Operator.Add L] : ℕ → Const L

Equations

• LO.FirstOrder.Semiterm.Operator.numeral L 0 = op(0)
• LO.FirstOrder.Semiterm.Operator.numeral L n.succ = op(+).foldr op(1) (List.replicate n op(1))

theorem LO.FirstOrder.Semiterm.Operator.numeral_zero {L : Language} [hz : Operator.Zero L] [ho : Operator.One L] [ha : Operator.Add L] : numeral L 0 = op(0)

theorem LO.FirstOrder.Semiterm.Operator.numeral_one {L : Language} [hz : Operator.Zero L] [ho : Operator.One L] [ha : Operator.Add L] : numeral L 1 = op(1)

theorem LO.FirstOrder.Semiterm.Operator.numeral_succ {L : Language} [hz : Operator.Zero L] [ho : Operator.One L] [ha : Operator.Add L] {z : ℕ} : z ≠ 0 → numeral L (z + 1) = op(+).comp ![numeral L z, op(1)]

theorem LO.FirstOrder.Semiterm.Operator.numeral_add_two {L : Language} [hz : Operator.Zero L] [ho : Operator.One L] [ha : Operator.Add L] {z : ℕ} : numeral L (z + 2) = op(+).comp ![numeral L (z + 1), op(1)]

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.Operator.encode (L : Language) [Operator.Zero L] [Operator.One L] [Operator.Add L] {α : Type u_1} [Encodable α] (a : α) : Const L

Equations

• LO.FirstOrder.Semiterm.Operator.encode L a = LO.FirstOrder.Semiterm.Operator.numeral L (Encodable.encode a)

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.Add.positive_iff {L : Language} {ξ : Type u_1} {n : ℕ} [L.Add] (t u : Semiterm L ξ (n + 1)) : (op(+).operator ![t, u]).Positive ↔ t.Positive ∧ u.Positive

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.Mul.positive_iff {L : Language} {ξ : Type u_1} {n : ℕ} [L.Mul] (t u : Semiterm L ξ (n + 1)) : (op(*).operator ![t, u]).Positive ↔ t.Positive ∧ u.Positive

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.Exp.positive_iff {L : Language} {ξ : Type u_1} {n : ℕ} [L.Exp] (t : Semiterm L ξ (n + 1)) : (exp.operator ![t]).Positive ↔ t.Positive

def LO.FirstOrder.Semiterm.Operator.npow (L : Language) [Operator.One L] [Operator.Mul L] (n : ℕ) : Operator L 1

Equations

• LO.FirstOrder.Semiterm.Operator.npow L n = op(*).foldr (LO.FirstOrder.Semiterm.Operator.comp op(1) ![]) (List.replicate n (LO.FirstOrder.Semiterm.Operator.bvar 0))

theorem LO.FirstOrder.Semiterm.Operator.npow_zero {L : Language} [Operator.One L] [Operator.Mul L] : npow L 0 = comp op(1) ![]

theorem LO.FirstOrder.Semiterm.Operator.npow_succ {L : Language} [Operator.One L] [Operator.Mul L] {n : ℕ} : npow L (n + 1) = op(*).comp ![npow L n, bvar 0]

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.npow_positive_iff {L : Language} {ξ : Type u_1} {n : ℕ} [Operator.One L] [L.Mul] (t : Semiterm L ξ (n + 1)) (k : ℕ) : ((npow L k).operator ![t]).Positive ↔ k = 0 ∨ t.Positive

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.Operator.GödelNumber.gödelNumber' {L : Language} {α : Type u_2} [GödelNumber L α] {ξ : Type u_3} {n : ℕ} (a : α) : Semiterm L ξ n

Equations

• LO.FirstOrder.Semiterm.Operator.GödelNumber.gödelNumber' a = ↑(LO.FirstOrder.Semiterm.Operator.GödelNumber.gödelNumber a)

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.GödelNumber.instGödelQuote {L : Language} {α : Type u_2} [GödelNumber L α] {ξ : Type u_3} {n : ℕ} : GödelQuote α (Semiterm L ξ n)

Equations

• LO.FirstOrder.Semiterm.Operator.GödelNumber.instGödelQuote = { quote := LO.FirstOrder.Semiterm.Operator.GödelNumber.gödelNumber' }

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.Operator.GödelNumber.ofEncodable {L : Language} [Operator.Zero L] [Operator.One L] [Operator.Add L] {α : Type u_1} [Encodable α] : GödelNumber L α

Equations

• LO.FirstOrder.Semiterm.Operator.GödelNumber.ofEncodable = { gödelNumber := LO.FirstOrder.Semiterm.Operator.encode L }

@[simp]

theorem LO.FirstOrder.Semiterm.complexity_zero {L : Language} {ξ : Type u_1} {n : ℕ} [L.Zero] : (↑op(0)).complexity = 1

@[simp]

theorem LO.FirstOrder.Semiterm.complexity_one {L : Language} {ξ : Type u_1} {n : ℕ} [L.One] : (↑op(1)).complexity = 1

@[simp]

theorem LO.FirstOrder.Semiterm.complexity_add {L : Language} {ξ : Type u_1} {n : ℕ} [L.Add] (t u : Semiterm L ξ n) : (op(+).operator ![t, u]).complexity = max t.complexity u.complexity + 1

@[simp]

theorem LO.FirstOrder.Semiterm.complexity_mul {L : Language} {ξ : Type u_1} {n : ℕ} [L.Mul] (t u : Semiterm L ξ n) : (op(*).operator ![t, u]).complexity = max t.complexity u.complexity + 1

def LO.FirstOrder.Semiterm.Operator.val {L : Language} {k : ℕ} {M : Type w} [s : Structure L M] (v : Fin k → M) (o : Operator L k) : M

Equations

• LO.FirstOrder.Semiterm.Operator.val v o = LO.FirstOrder.Semiterm.val v Empty.elim o.term

@[simp]

theorem LO.FirstOrder.Semiterm.val_operator {L : Language} {M : Type w} {s : Structure L M} {n : ℕ} {ξ : Type u_1} {k : ℕ} (b : Fin n → M) (f : ξ → M) (o : Operator L k) (v : Fin k → Semiterm L ξ n) : val b f (o.operator v) = Operator.val (val b f ∘ v) o

theorem LO.FirstOrder.Semiterm.val_operator' {L : Language} {M : Type w} {s : Structure L M} {ξ : Type u_1} {k : ℕ} (b : Fin k → M) (f : ξ → M) (o : Operator L k) (v : Fin k → Semiterm L ξ k) : val b f (o.operator v) = Operator.val (fun (i : Fin k) => val b f (v i)) o

theorem LO.FirstOrder.Semiterm.Operator.val_comp {L : Language} {M : Type w} {s : Structure L M} {k m : ℕ} (o₁ : Operator L k) (o₂ : Fin k → Operator L m) (v : Fin m → M) : val v (o₁.comp o₂) = val (val v ∘ o₂) o₁

@[simp]

theorem LO.FirstOrder.Semiterm.Operator.val_bvar {L : Language} {M : Type w} {s : Structure L M} {n : ℕ} (x : Fin n) (v : Fin n → M) : val v (bvar x) = v x

structure LO.FirstOrder.Semiformula.Operator (L : Language) (n : ℕ) : Type u

• sentence : Semisentence L n

@[reducible, inline]

abbrev LO.FirstOrder.Semiformula.Const (L : Language) : Type u

Equations

• LO.FirstOrder.Semiformula.Const L = LO.FirstOrder.Semiformula.Operator L 0

def LO.FirstOrder.Semiformula.Operator.operator {L : Language} {ξ : Type u_2} {n arity : ℕ} (o : Operator L arity) (v : Fin arity → Semiterm L ξ n) : Semiformula L ξ n

Equations

• o.operator v = LO.FirstOrder.Rewriting.emb o.sentence ⇜ v

def LO.FirstOrder.Semiformula.Operator.const {L : Language} {ξ : Type u_2} {n : ℕ} (c : Const L) : Semiformula L ξ n

Equations

• ↑c = LO.FirstOrder.Semiformula.Operator.operator c ![]

@[implicit_reducible]

instance LO.FirstOrder.Semiformula.Operator.instCoeConst {L : Language} {ξ : Type u_2} {n : ℕ} : Coe (Const L) (Semiformula L ξ n)

Equations

• LO.FirstOrder.Semiformula.Operator.instCoeConst = { coe := LO.FirstOrder.Semiformula.Operator.const }

def LO.FirstOrder.Semiformula.Operator.comp {L : Language} {k l : ℕ} (o : Operator L k) (w : Fin k → Semiterm.Operator L l) : Operator L l

Equations

• o.comp w = { sentence := o.operator fun (x : Fin k) => (w x).term }

theorem LO.FirstOrder.Semiformula.Operator.operator_comp {L : Language} {k l : ℕ} {ξ : Type u_1} {n : ℕ} (o : Operator L k) (w : Fin k → Semiterm.Operator L l) (v : Fin l → Semiterm L ξ n) : (o.comp w).operator v = o.operator fun (x : Fin k) => (w x).operator v

def LO.FirstOrder.Semiformula.Operator.and {L : Language} {k : ℕ} (o₁ o₂ : Operator L k) : Operator L k

Equations

• o₁.and o₂ = { sentence := o₁.sentence ⋏ o₂.sentence }

def LO.FirstOrder.Semiformula.Operator.or {L : Language} {k : ℕ} (o₁ o₂ : Operator L k) : Operator L k

Equations

• o₁.or o₂ = { sentence := o₁.sentence ⋎ o₂.sentence }

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.operator_and {L : Language} {k : ℕ} {ξ : Type u_1} {n : ℕ} (o₁ o₂ : Operator L k) (v : Fin k → Semiterm L ξ n) : (o₁.and o₂).operator v = o₁.operator v ⋏ o₂.operator v

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.operator_or {L : Language} {k : ℕ} {ξ : Type u_1} {n : ℕ} (o₁ o₂ : Operator L k) (v : Fin k → Semiterm L ξ n) : (o₁.or o₂).operator v = o₁.operator v ⋎ o₂.operator v

class LO.FirstOrder.Semiformula.Operator.Eq (L : Language) : Type u_1

• eq : Operator L 2

class LO.FirstOrder.Semiformula.Operator.LT (L : Language) : Type u_1

• lt : Operator L 2

class LO.FirstOrder.Semiformula.Operator.LE (L : Language) : Type u_1

• le : Operator L 2

class LO.FirstOrder.Semiformula.Operator.Mem (L : Language) : Type u_1

• mem : Operator L 2

def LO.FirstOrder.Semiformula.Operator.«termOp(=)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiformula.Operator.«termOp(=)» = Lean.ParserDescr.node `LO.FirstOrder.Semiformula.Operator.«termOp(=)» 1024 (Lean.ParserDescr.symbol "op(=)")

def LO.FirstOrder.Semiformula.Operator.«termOp(=)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiformula.Operator.«termOp(<)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiformula.Operator.«termOp(<)» = Lean.ParserDescr.node `LO.FirstOrder.Semiformula.Operator.«termOp(<)» 1024 (Lean.ParserDescr.symbol "op(<)")

def LO.FirstOrder.Semiformula.Operator.«termOp(<)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiformula.Operator.«termOp(≤)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiformula.Operator.«termOp(≤)» = Lean.ParserDescr.node `LO.FirstOrder.Semiformula.Operator.«termOp(≤)» 1024 (Lean.ParserDescr.symbol "op(≤)")

def LO.FirstOrder.Semiformula.Operator.«termOp(≤)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def LO.FirstOrder.Semiformula.Operator.«termOp(∈)» : Lean.ParserDescr

Equations

• LO.FirstOrder.Semiformula.Operator.«termOp(∈)» = Lean.ParserDescr.node `LO.FirstOrder.Semiformula.Operator.«termOp(∈)» 1024 (Lean.ParserDescr.symbol "op(∈)")

def LO.FirstOrder.Semiformula.Operator.«termOp(∈)[_]» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance LO.FirstOrder.Semiformula.Operator.instEqOfEq {L : Language} [L.Eq] : Operator.Eq L

Equations

• LO.FirstOrder.Semiformula.Operator.instEqOfEq = { eq := { sentence := LO.FirstOrder.Semiformula.rel LO.FirstOrder.Language.Eq.eq LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiformula.Operator.instLTOfLT {L : Language} [L.LT] : Operator.LT L

Equations

• LO.FirstOrder.Semiformula.Operator.instLTOfLT = { lt := { sentence := LO.FirstOrder.Semiformula.rel LO.FirstOrder.Language.LT.lt LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiformula.Operator.instMemOfMem {L : Language} [L.Mem] : Operator.Mem L

Equations

• LO.FirstOrder.Semiformula.Operator.instMemOfMem = { mem := { sentence := LO.FirstOrder.Semiformula.rel LO.FirstOrder.Language.Mem.mem LO.FirstOrder.Semiterm.bvar } }

@[implicit_reducible]

instance LO.FirstOrder.Semiformula.Operator.instLEOfEqOfLT {L : Language} [Operator.Eq L] [Operator.LT L] : Operator.LE L

Equations

• LO.FirstOrder.Semiformula.Operator.instLEOfEqOfLT = { le := op(=).or op(<) }

theorem LO.FirstOrder.Semiformula.Operator.Eq.sentence_eq {L : Language} [L.Eq] : op(=).sentence = rel Language.Eq.eq Semiterm.bvar

theorem LO.FirstOrder.Semiformula.Operator.LT.sentence_eq {L : Language} [L.LT] : op(<).sentence = rel Language.LT.lt Semiterm.bvar

theorem LO.FirstOrder.Semiformula.Operator.Mem.sentence_eq {L : Language} [L.Mem] : op(∈).sentence = rel Language.Mem.mem Semiterm.bvar

theorem LO.FirstOrder.Semiformula.Operator.LE.sentence_eq {L : Language} [L.Eq] [L.LT] : op(≤).sentence = op(=).sentence ⋎ op(<).sentence

theorem LO.FirstOrder.Semiformula.Operator.LE.def_of_Eq_of_LT {L : Language} [Operator.Eq L] [Operator.LT L] : op(≤) = op(=).or op(<)

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.Eq.equal_inj {L : Language} {ξ₂ : Type u_1} {n₂ : ℕ} [L.Eq] {t₁ t₂ u₁ u₂ : Semiterm L ξ₂ n₂} : op(=).operator ![t₁, u₁] = op(=).operator ![t₂, u₂] ↔ t₁ = t₂ ∧ u₁ = u₂

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.LT.lt_inj {L : Language} {ξ₂ : Type u_1} {n₂ : ℕ} [L.LT] {t₁ t₂ u₁ u₂ : Semiterm L ξ₂ n₂} : op(<).operator ![t₁, u₁] = op(<).operator ![t₂, u₂] ↔ t₁ = t₂ ∧ u₁ = u₂

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.Mem.mem_inj {L : Language} {ξ₂ : Type u_1} {n₂ : ℕ} [L.Mem] {t₁ t₂ u₁ u₂ : Semiterm L ξ₂ n₂} : op(∈).operator ![t₁, u₁] = op(∈).operator ![t₂, u₂] ↔ t₁ = t₂ ∧ u₁ = u₂

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.LE.le_inj {L : Language} {ξ₂ : Type u_1} {n₂ : ℕ} [L.Eq] [L.LT] {t₁ t₂ u₁ u₂ : Semiterm L ξ₂ n₂} : op(≤).operator ![t₁, u₁] = op(≤).operator ![t₂, u₂] ↔ t₁ = t₂ ∧ u₁ = u₂

theorem LO.FirstOrder.Semiformula.Operator.lt_def {L : Language} {ξ : Type u_1} {n : ℕ} [L.LT] (t u : Semiterm L ξ n) : op(<).operator ![t, u] = rel Language.LT.lt ![t, u]

theorem LO.FirstOrder.Semiformula.Operator.eq_def {L : Language} {ξ : Type u_1} {n : ℕ} [L.Eq] (t u : Semiterm L ξ n) : op(=).operator ![t, u] = rel Language.Eq.eq ![t, u]

theorem LO.FirstOrder.Semiformula.Operator.mem_def {L : Language} {ξ : Type u_1} {n : ℕ} [L.Mem] (t u : Semiterm L ξ n) : op(∈).operator ![t, u] = rel Language.Mem.mem ![t, u]

theorem LO.FirstOrder.Semiformula.Operator.le_def {L : Language} {ξ : Type u_1} {n : ℕ} [L.Eq] [L.LT] (t u : Semiterm L ξ n) : op(≤).operator ![t, u] = rel Language.Eq.eq ![t, u] ⋎ rel Language.LT.lt ![t, u]

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.Eq.open {L : Language} {ξ : Type u_1} {n : ℕ} [L.Eq] (t u : Semiterm L ξ n) : (op(=).operator ![t, u]).Open

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.LT.open {L : Language} {ξ : Type u_1} {n : ℕ} [L.LT] (t u : Semiterm L ξ n) : (op(<).operator ![t, u]).Open

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.Mem.open {L : Language} {ξ : Type u_1} {n : ℕ} [L.Mem] (t u : Semiterm L ξ n) : (op(∈).operator ![t, u]).Open

@[simp]

theorem LO.FirstOrder.Semiformula.Operator.LE.open {L : Language} {ξ : Type u_1} {n : ℕ} [L.Eq] [L.LT] (t u : Semiterm L ξ n) : (op(≤).operator ![t, u]).Open

def LO.FirstOrder.Semiformula.Operator.val {L : Language} {M : Type w} [s : Structure L M] {k : ℕ} (v : Fin k → M) (o : Operator L k) : Prop

Equations

• LO.FirstOrder.Semiformula.Operator.val v o = (LO.FirstOrder.Semiformula.Eval v Empty.elim) o.sentence

@[simp]

theorem LO.FirstOrder.Semiformula.val_operator_and {L : Language} {M : Type w} {s : Structure L M} {k : ℕ} {o₁ o₂ : Operator L k} {v : Fin k → M} : Operator.val v (o₁.and o₂) ↔ Operator.val v o₁ ∧ Operator.val v o₂

@[simp]

theorem LO.FirstOrder.Semiformula.val_operator_or {L : Language} {M : Type w} {s : Structure L M} {k : ℕ} {o₁ o₂ : Operator L k} {v : Fin k → M} : Operator.val v (o₁.or o₂) ↔ Operator.val v o₁ ∨ Operator.val v o₂

@[simp]

theorem LO.FirstOrder.Semiformula.eval_operator {L : Language} {M : Type w} {s : Structure L M} {n : ℕ} {ξ : Type u_1} {k : ℕ} {o : Operator L k} {e : Fin n → M} {f : ξ → M} {v : Fin k → Semiterm L ξ n} : (Eval e f) (o.operator v) ↔ Operator.val (Semiterm.val e f ∘ v) o

def LO.FirstOrder.Semiformula.ballLT {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.LT L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.ballLT t φ = ∀⁰[op(<).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

def LO.FirstOrder.Semiformula.bexsLT {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.LT L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.bexsLT t φ = ∃⁰[op(<).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

def LO.FirstOrder.Semiformula.ballLE {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.LE L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.ballLE t φ = ∀⁰[op(≤).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

def LO.FirstOrder.Semiformula.bexsLE {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.LE L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.bexsLE t φ = ∃⁰[op(≤).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

def LO.FirstOrder.Semiformula.ballMem {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.Mem L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.ballMem t φ = ∀⁰[op(∈).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

def LO.FirstOrder.Semiformula.bexsMem {L : Language} {ξ : Type u_2} {n : ℕ} [Operator.Mem L] (t : Semiterm L ξ n) (φ : Semiformula L ξ (n + 1)) : Semiformula L ξ n

Equations

• LO.FirstOrder.Semiformula.bexsMem t φ = ∃⁰[op(∈).operator ![LO.FirstOrder.Semiterm.bvar 0, LO.FirstOrder.Rew.bShift t]] φ

theorem LO.FirstOrder.Rew.operator {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) {k : ℕ} (o : Semiterm.Operator L k) (v : Fin k → Semiterm L ξ₁ n₁) : ω (o.operator v) = o.operator fun (i : Fin k) => ω (v i)

theorem LO.FirstOrder.Rew.operator' {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) {k : ℕ} (o : Semiterm.Operator L k) (v : Fin k → Semiterm L ξ₁ n₁) : ω (o.operator v) = o.operator (⇑ω ∘ v)

@[simp]

theorem LO.FirstOrder.Rew.finitary0 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiterm.Operator L 0) (v : Fin 0 → Semiterm L ξ₁ n₁) : ω (o.operator v) = o.operator ![]

@[simp]

theorem LO.FirstOrder.Rew.finitary1 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiterm.Operator L 1) (t : Semiterm L ξ₁ n₁) : ω (o.operator ![t]) = o.operator ![ω t]

@[simp]

theorem LO.FirstOrder.Rew.finitary2 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiterm.Operator L 2) (t₁ t₂ : Semiterm L ξ₁ n₁) : ω (o.operator ![t₁, t₂]) = o.operator ![ω t₁, ω t₂]

@[simp]

theorem LO.FirstOrder.Rew.finitary3 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiterm.Operator L 3) (t₁ t₂ t₃ : Semiterm L ξ₁ n₁) : ω (o.operator ![t₁, t₂, t₃]) = o.operator ![ω t₁, ω t₂, ω t₃]

@[simp]

theorem LO.FirstOrder.Rew.const {ξ₁ : Type u_2} {n₁ : ℕ} {ξ₂ : Type u_1} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (c : Semiterm.Const L) : ω ↑c = ↑c

theorem LO.FirstOrder.Rew.hom_operator {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) {k : ℕ} (o : Semiformula.Operator L k) (v : Fin k → Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator v) = o.operator fun (i : Fin k) => ω (v i)

theorem LO.FirstOrder.Rew.hom_operator' {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) {k : ℕ} (o : Semiformula.Operator L k) (v : Fin k → Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator v) = o.operator (⇑ω ∘ v)

@[simp]

theorem LO.FirstOrder.Rew.hom_finitary0 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiformula.Operator L 0) (v : Fin 0 → Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator v) = o.operator ![]

@[simp]

theorem LO.FirstOrder.Rew.hom_finitary1 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiformula.Operator L 1) (t : Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator ![t]) = o.operator ![ω t]

@[simp]

theorem LO.FirstOrder.Rew.hom_finitary2 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiformula.Operator L 2) (t₁ t₂ : Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator ![t₁, t₂]) = o.operator ![ω t₁, ω t₂]

@[simp]

theorem LO.FirstOrder.Rew.hom_finitary3 {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) (o : Semiformula.Operator L 3) (t₁ t₂ t₃ : Semiterm L ξ₁ n₁) : (Rewriting.app ω) (o.operator ![t₁, t₂, t₃]) = o.operator ![ω t₁, ω t₂, ω t₃]

@[simp]

theorem LO.FirstOrder.Rew.hom_const {ξ₁ : Type u_2} {n₁ : ℕ} {ξ₂ : Type u_1} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) {c : Semiformula.Const L} : (Rewriting.app ω) ↑c = ↑c

theorem LO.FirstOrder.Rew.eq_equal_iff {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) [L.Eq] {φ : Semiformula L ξ₁ n₁} {t u : Semiterm L ξ₂ n₂} : (Rewriting.app ω) φ = op(=).operator ![t, u] ↔ ∃ (t' : Semiterm L ξ₁ n₁) (u' : Semiterm L ξ₁ n₁), ω t' = t ∧ ω u' = u ∧ φ = op(=).operator ![t', u']

theorem LO.FirstOrder.Rew.eq_lt_iff {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) [L.LT] {φ : Semiformula L ξ₁ n₁} {t u : Semiterm L ξ₂ n₂} : (Rewriting.app ω) φ = op(<).operator ![t, u] ↔ ∃ (t' : Semiterm L ξ₁ n₁) (u' : Semiterm L ξ₁ n₁), ω t' = t ∧ ω u' = u ∧ φ = op(<).operator ![t', u']

theorem LO.FirstOrder.Rew.eq_mem_iff {ξ₁ : Type u_1} {n₁ : ℕ} {ξ₂ : Type u_2} {n₂ : ℕ} {L : Language} (ω : Rew L ξ₁ n₁ ξ₂ n₂) [L.Mem] {φ : Semiformula L ξ₁ n₁} {t u : Semiterm L ξ₂ n₂} : (Rewriting.app ω) φ = op(∈).operator ![t, u] ↔ ∃ (t' : Semiterm L ξ₁ n₁) (u' : Semiterm L ξ₁ n₁), ω t' = t ∧ ω u' = u ∧ φ = op(∈).operator ![t', u']

class LO.FirstOrder.Structure.Zero (L : Language) (M : Type u_1) [Structure L M] [Semiterm.Operator.Zero L] [Zero M] : Prop

• zero : Semiterm.Operator.val ![] op(0) = 0

class LO.FirstOrder.Structure.One (L : Language) (M : Type u_1) [Structure L M] [Semiterm.Operator.One L] [One M] : Prop

• one : Semiterm.Operator.val ![] op(1) = 1

class LO.FirstOrder.Structure.Add (L : Language) (M : Type u_1) [Structure L M] [Semiterm.Operator.Add L] [Add M] : Prop

• add (a b : M) : Semiterm.Operator.val ![a, b] op(+) = a + b

class LO.FirstOrder.Structure.Mul (L : Language) (M : Type u_1) [Structure L M] [Semiterm.Operator.Mul L] [Mul M] : Prop

• mul (a b : M) : Semiterm.Operator.val ![a, b] op(*) = a * b

class LO.FirstOrder.Structure.Exp (L : Language) (M : Type u_1) [Structure L M] [Semiterm.Operator.Exp L] [Exp M] : Prop

• exp (a : M) : Semiterm.Operator.val ![a] Semiterm.Operator.Exp.exp = LO.Exp.exp a

class LO.FirstOrder.Structure.Eq (L : Language) (M : Type u_1) [Structure L M] [Semiformula.Operator.Eq L] : Prop

• eq (a b : M) : Semiformula.Operator.val ![a, b] op(=) ↔ a = b

class LO.FirstOrder.Structure.LT (L : Language) (M : Type u_1) [Structure L M] [Semiformula.Operator.LT L] [LT M] : Prop

• lt (a b : M) : Semiformula.Operator.val ![a, b] op(<) ↔ a < b

class LO.FirstOrder.Structure.LE (L : Language) (M : Type u_1) [Structure L M] [Semiformula.Operator.LE L] [LE M] : Prop

• le (a b : M) : Semiformula.Operator.val ![a, b] op(≤) ↔ a ≤ b

class LO.FirstOrder.Structure.Mem (L : Language) (M : Type u_1) [Structure L M] [Semiformula.Operator.Mem L] [Membership M M] : Prop

• mem (a b : M) : Semiformula.Operator.val ![a, b] op(∈) ↔ a ∈ b

instance LO.FirstOrder.Structure.instLEOfEqOfLT (L : Language) (M : Type u_1) [Structure L M] [L.Eq] [L.LT] [Structure.Eq L M] [PartialOrder M] [Structure.LT L M] : Structure.LE L M

@[simp]

theorem LO.FirstOrder.Structure.zero_eq_of_lang {L : Language} {M : Type u_1} [Structure L M] [L.Zero] [Zero M] [Structure.Zero L M] (v : Fin 0 → M) : func Language.Zero.zero v = 0

@[simp]

theorem LO.FirstOrder.Structure.one_eq_of_lang {L : Language} {M : Type u_1} [Structure L M] [L.One] [One M] [Structure.One L M] (v : Fin 0 → M) : func Language.One.one v = 1

@[simp]

theorem LO.FirstOrder.Structure.add_eq_of_lang {L : Language} {M : Type u_1} [Structure L M] [L.Add] [Add M] [Structure.Add L M] {v : Fin 2 → M} : func Language.Add.add v = v 0 + v 1

@[simp]

theorem LO.FirstOrder.Structure.mul_eq_of_lang {L : Language} {M : Type u_1} [Structure L M] [L.Mul] [Mul M] [Structure.Mul L M] {v : Fin 2 → M} : func Language.Mul.mul v = v 0 * v 1

@[simp]

theorem LO.FirstOrder.Structure.exp_eq_of_lang {L : Language} {M : Type u_1} [Structure L M] [L.Exp] [Exp M] [Structure.Exp L M] {v : Fin 1 → M} : func Language.Exp.exp v = LO.Exp.exp (v 0)

@[simp]

theorem LO.FirstOrder.Structure.eq_iff_eq {L : Language} {M : Type u_1} [Structure L M] [Semiformula.Operator.Eq L] [Structure.Eq L M] {v : Fin 2 → M} : Semiformula.Operator.val v op(=) ↔ v 0 = v 1

@[simp]

theorem LO.FirstOrder.Structure.lt_iff_lt {L : Language} {M : Type u_1} [Structure L M] [Semiformula.Operator.LT L] [LT M] [Structure.LT L M] {v : Fin 2 → M} : Semiformula.Operator.val v op(<) ↔ v 0 < v 1

@[simp]

theorem LO.FirstOrder.Structure.mem_iff_mem {L : Language} {M : Type u_1} [Structure L M] [Semiformula.Operator.Mem L] [Membership M M] [Structure.Mem L M] {v : Fin 2 → M} : Semiformula.Operator.val v op(∈) ↔ v 0 ∈ v 1

theorem LO.FirstOrder.Structure.le_iff_of_eq_of_lt {L : Language} {M : Type u_1} [Structure L M] [Semiformula.Operator.Eq L] [Semiformula.Operator.LT L] [LT M] [Structure.Eq L M] [Structure.LT L M] {a b : M} : Semiformula.Operator.val ![a, b] op(≤) ↔ a = b ∨ a < b

@[simp]

theorem LO.FirstOrder.Structure.eq_lang {L : Language} {M : Type u_1} [Structure L M] [L.Eq] [Structure.Eq L M] {v : Fin 2 → M} : rel Language.Eq.eq v ↔ v 0 = v 1

@[simp]

theorem LO.FirstOrder.Structure.lt_lang {L : Language} {M : Type u_1} [Structure L M] [L.LT] [LT M] [Structure.LT L M] {v : Fin 2 → M} : rel Language.LT.lt v ↔ v 0 < v 1

@[simp]

theorem LO.FirstOrder.Structure.mem_lang {L : Language} {M : Type u_1} [Structure L M] [L.Mem] [Membership M M] [Structure.Mem L M] {v : Fin 2 → M} : rel Language.Mem.mem v ↔ v 0 ∈ v 1

theorem LO.FirstOrder.Structure.operator_val_ofEquiv_iff {L : Language} {M : Type u_1} [Structure L M] {N : Type u_2} (φ : M ≃ N) {k : ℕ} {o : Semiformula.Operator L k} {v : Fin k → N} : Semiformula.Operator.val v o ↔ Semiformula.Operator.val (⇑φ.symm ∘ v) o

@[simp]

theorem LO.FirstOrder.Semiformula.eval_ballLT {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.LT L] [LT M] [Structure.LT L M] : (Eval e f) (ballLT t φ) ↔ ∀ x < Semiterm.val e f t, (Eval (x :> e) f) φ

@[simp]

theorem LO.FirstOrder.Semiformula.eval_bexsLT {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.LT L] [LT M] [Structure.LT L M] : (Eval e f) (bexsLT t φ) ↔ ∃ x < Semiterm.val e f t, (Eval (x :> e) f) φ

@[simp]

theorem LO.FirstOrder.Semiformula.eval_ballLE {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.LE L] [LE M] [Structure.LE L M] : (Eval e f) (ballLE t φ) ↔ ∀ x ≤ Semiterm.val e f t, (Eval (x :> e) f) φ

@[simp]

theorem LO.FirstOrder.Semiformula.eval_bexsLE {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.LE L] [LE M] [Structure.LE L M] : (Eval e f) (bexsLE t φ) ↔ ∃ x ≤ Semiterm.val e f t, (Eval (x :> e) f) φ

@[simp]

theorem LO.FirstOrder.Semiformula.eval_ballMem {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.Mem L] [Membership M M] [Structure.Mem L M] : (Eval e f) (ballMem t φ) ↔ ∀ x ∈ Semiterm.val e f t, (Eval (x :> e) f) φ

@[simp]

theorem LO.FirstOrder.Semiformula.eval_bexsMem {n : ℕ} {ξ : Type u_3} {L : Language} {M : Type u_1} {s : Structure L M} {e : Fin n → M} {f : ξ → M} {t : Semiterm L ξ n} {φ : Semiformula L ξ (n + 1)} [Operator.Mem L] [Membership M M] [Structure.Mem L M] : (Eval e f) (bexsMem t φ) ↔ ∃ x ∈ Semiterm.val e f t, (Eval (x :> e) f) φ

@[reducible, inline]

abbrev LO.FirstOrder.Semiterm.numeral {L : Language} [L.Zero] [L.One] [L.Add] {ξ : Type u_2} {n : ℕ} (k : ℕ) : Semiterm L ξ n

Equations

• ↑k = ↑(LO.FirstOrder.Semiterm.Operator.numeral L k)

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.instCoeNat {L : Language} [L.Zero] [L.One] [L.Add] {ξ : Type u_2} {n : ℕ} : Coe ℕ (Semiterm L ξ n)

Equations

• LO.FirstOrder.Semiterm.instCoeNat = { coe := LO.FirstOrder.Semiterm.numeral }