Operator

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

Imported declaration from the Incompleteness formalization.

• term : Semiterm L Empty n

  Imported declaration from the Incompleteness formalization.

@[reducible, inline]

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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 ≃ Semiterm L Empty n

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

Equations

• o.operator v = (LO.FirstOrder.Rew.substs 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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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 = o.term.bv.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 ∈ o.term.bv, (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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• zero : Const L

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• one : Const L

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• add : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• mul : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• exp : Operator L 1

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• sub : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• div : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• star : Const L

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• goedelNumber : α → Const L

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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(1)» : Lean.ParserDescr

Imported declaration from the Incompleteness formalization.

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(+)» : Lean.ParserDescr

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

Equations

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

@[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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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.GoedelNumber.goedelNumber' {L : Language} {α : Type u_2} [GoedelNumber L α] {ξ : Type u_3} {n : ℕ} (a : α) : Semiterm L ξ n

Imported declaration from the Incompleteness formalization.

Equations

• LO.FirstOrder.Semiterm.Operator.GoedelNumber.goedelNumber' a = ↑(LO.FirstOrder.Semiterm.Operator.GoedelNumber.goedelNumber a)

@[implicit_reducible]

instance LO.FirstOrder.Semiterm.Operator.GoedelNumber.instGoedelQuote {L : Language} {α : Type u_2} [GoedelNumber L α] {ξ : Type u_3} {n : ℕ} : GoedelQuote α (Semiterm L ξ n)

Equations

• LO.FirstOrder.Semiterm.Operator.GoedelNumber.instGoedelQuote = { quote := LO.FirstOrder.Semiterm.Operator.GoedelNumber.goedelNumber' }

@[reducible]

def LO.FirstOrder.Semiterm.Operator.GoedelNumber.ofEncodable {L : Language} [Operator.Zero L] [Operator.One L] [Operator.Add L] {α : Type u_1} [Encodable α] : GoedelNumber L α

Imported declaration from the Incompleteness formalization.

Equations

• LO.FirstOrder.Semiterm.Operator.GoedelNumber.ofEncodable = { goedelNumber := 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] (o : Operator L k) (v : Fin k → M) : M

Imported declaration from the Incompleteness formalization.

Equations

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

theorem LO.FirstOrder.Semiterm.val_operator {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} {k : ℕ} (o : Operator L k) (v : Fin k → Semiterm L ξ✝ n✝) : val s e ε (o.operator v) = o.val fun (x : Fin k) => val s e ε (v x)

@[simp]

theorem LO.FirstOrder.Semiterm.val_const {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} (o : Const L) : val s e ε ↑o = Operator.val o ![]

@[simp]

theorem LO.FirstOrder.Semiterm.val_operator₀ {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} {v : Fin 0 → Semiterm L ξ✝ n✝} (o : Const L) : val s e ε (Operator.operator o v) = Operator.val o ![]

@[simp]

theorem LO.FirstOrder.Semiterm.val_operator₁ {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} {t : Semiterm L ξ✝ n✝} (o : Operator L 1) : val s e ε (o.operator ![t]) = o.val ![val s e ε t]

@[simp]

theorem LO.FirstOrder.Semiterm.val_operator₂ {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} (o : Operator L 2) (t u : Semiterm L ξ✝ n✝) : val s e ε (o.operator ![t, u]) = o.val ![val s e ε t, val s e ε u]

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) : (o₁.comp o₂).val v = o₁.val fun (i : Fin k) => (o₂ i).val v

@[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) : (bvar x).val v = v x

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

Imported declaration from the Incompleteness formalization.

• sentence : Semisentence L n

  Imported declaration from the Incompleteness formalization.

@[reducible, inline]

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

Equations

• o.operator v = ↑o.sentence <~ v

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• eq : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• lt : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• le : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

• mem : Operator L 2

  Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

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

Imported declaration from the Incompleteness formalization.

Equations

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

@[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.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.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.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.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.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 : ℕ} (o : Operator L k) (v : Fin k → M) : Prop

Imported declaration from the Incompleteness formalization.

Equations

• o.val v = (LO.FirstOrder.Semiformula.Eval s 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} : (o₁.and o₂).val v ↔ o₁.val v ∧ o₂.val v

@[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} : (o₁.or o₂).val v ↔ o₁.val v ∨ o₂.val v

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

@[simp]

theorem LO.FirstOrder.Semiformula.eval_operator₀ {L : Language} {M : Type w} {s : Structure L M} {n✝ : ℕ} {e : Fin n✝ → M} {ξ✝ : Type u_1} {ε : ξ✝ → M} {o : Const L} {v : Fin 0 → Semiterm L ξ✝ n✝} : (Eval s e ε) (Operator.operator o v) ↔ Operator.val o ![]

@[simp]

theorem LO.FirstOrder.Semiformula.eval_operator₁ {L : Language} {M : Type w} {s : Structure L M} {ξ : Type u_1} {n : ℕ} {e : Fin n → M} {ε : ξ → M} {o : Operator L 1} {t : Semiterm L ξ n} : (Eval s e ε) (o.operator ![t]) ↔ o.val ![Semiterm.val s e ε t]

@[simp]

theorem LO.FirstOrder.Semiformula.eval_operator₂ {L : Language} {M : Type w} {s : Structure L M} {ξ : Type u_1} {n : ℕ} {e : Fin n → M} {ε : ξ → M} {o : Operator L 2} {t₁ t₂ : Semiterm L ξ n} : (Eval s e ε) (o.operator ![t₁, t₂]) ↔ o.val ![Semiterm.val s e ε t₁, Semiterm.val s e ε t₂]

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

Imported declaration from the Incompleteness formalization.

Equations

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

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

Imported declaration from the Incompleteness formalization.

Equations

• LO.FirstOrder.Semiformula.bexLT 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

Imported declaration from the Incompleteness formalization.

Equations

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

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

Imported declaration from the Incompleteness formalization.

Equations

• LO.FirstOrder.Semiformula.bexLE 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

Imported declaration from the Incompleteness formalization.

Equations

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

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

Imported declaration from the Incompleteness formalization.

Equations

• LO.FirstOrder.Semiformula.bexMem 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']

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

Imported declaration from the Incompleteness formalization.

• 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

Imported declaration from the Incompleteness formalization.

• 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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

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

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

Imported declaration from the Incompleteness formalization.

• mem (a b : M) : op(∈).val ![a, b] ↔ 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] : func Language.Zero.zero ![] = 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] : func Language.One.one ![] = 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 = exp (v 0)

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} : op(≤).val ![a, b] ↔ 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

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} : o.val v ↔ o.val (⇑φ.symm ∘ v)

@[simp]

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

@[simp]

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

@[simp]

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

@[simp]

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

@[simp]

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

@[simp]

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

@[reducible, inline]

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

Imported declaration from the Incompleteness formalization.

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 }