Documentation

MathematicalLogic.FirstOrder.Syntax

Syntax of first-order logic #

This file defines the syntax of first-order logic.

Definitions #

Equational theory #

We formalize the equational theory of de Bruijn substitutions, extending the Autosubst paper with well-scoped syntax and a much richer set of operations.

We tag the rewriting rules in Autosubst paper with the simp set syntax_simp. Tactic syntax_simp uses these rules to rewrite FOL syntaxes to their normal forms, e.g.

example {L : Language} {n m : ℕ} {t : L.Term (n + 1)} {t' : L.Term n} {σ : L.Subst n m} :
    t[↦ₛ t']ₜ[σ]ₜ = t[⇑ₛσ]ₜ[↦ₛ t'[σ]ₜ]ₜ := by
  syntax_simp

This is not a complete decision procedure like the Autosubst paper does, though it already solves a lot of equalities.

Design note #

References #

First-order language. L.Func n is the type of n-ary functions, and L.Rel n is the type of n-ary relations (predicates).

Note: Func and Rel are Types, since there is no need for higher universe level right now.

Instances For
    @[reducible, inline]
    Equations
    Instances For
      inductive FirstOrder.Language.Term (L : Language) (n : ) :

      L.Term n is the type of terms with variables indexed by Fin n.

      Instances For

        A variable indexed by Fin n.

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

          A function symbol applied by a vector of terms.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            instance FirstOrder.Language.Term.decEq {L : Language} {n : } [(n : ) → DecidableEq (L.Func n)] :
            Equations
            • One or more equations did not get rendered due to their size.
            Equations
            Instances For
              @[simp]
              theorem FirstOrder.Language.Term.sizeOf_lt_func {L : Language} {n m : } {f : L.Func m} {v : Fin mL.Term n} {i : Fin m} :
              sizeOf (v i) < sizeOf (f ⬝ᶠ v)

              σ : L.Subst n m substitutes variable i : Fin n into a term σ i : L.Term m. This is defined as Fin n → L.Term m, but Subst.of should be used to create substitution from raw vectors.

              Equations
              Instances For
                theorem FirstOrder.Language.Subst.ext {L : Language} {n m : } {σ₁ σ₂ : L.Subst n m} :
                (∀ (i : Fin n), σ₁ i = σ₂ i)σ₁ = σ₂
                theorem FirstOrder.Language.Subst.ext_iff {L : Language} {n m : } {σ₁ σ₂ : L.Subst n m} :
                σ₁ = σ₂ ∀ (i : Fin n), σ₁ i = σ₂ i
                def FirstOrder.Language.Term.subst {L : Language} {n m : } :
                L.Term nL.Subst n mL.Term m

                Substitution of a term.

                Equations
                Instances For

                  Substitution of a term.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      @[simp]
                      theorem FirstOrder.Language.Term.subst_var {L : Language} {n m : } {σ : L.Subst n m} {i : Fin n} :
                      (#i)[σ]ₜ = σ i
                      @[simp]
                      theorem FirstOrder.Language.Term.subst_func {L : Language} {n m k : } {σ : L.Subst n m} {f : L.Func k} {v : Vec (L.Term n) k} :
                      (f ⬝ᶠ v)[σ]ₜ = f ⬝ᶠ fun (i : Fin k) => (v i)[σ]ₜ
                      theorem FirstOrder.Language.Term.subst_const {L : Language} {n m : } {σ : L.Subst n m} {c : L.Const} :
                      def FirstOrder.Language.Subst.of {L : Language} {n m : } (v : Vec (L.Term m) n) :
                      L.Subst n m
                      Equations
                      Instances For
                        @[simp]
                        theorem FirstOrder.Language.Subst.of_apply {L : Language} {n m : } {i : Fin n} {v : Fin nL.Term m} :
                        of v i = v i

                        Identical substitution.

                        Equations
                        Instances For

                          Identical substitution.

                          Equations
                          Instances For
                            theorem FirstOrder.Language.Subst.id_def {L : Language} {n : } :
                            idₛ = of fun (i : Fin n) => #i
                            @[simp]
                            theorem FirstOrder.Language.Subst.id_apply {L : Language} {n : } {i : Fin n} :
                            idₛ i = #i
                            @[simp]
                            def FirstOrder.Language.Subst.comp {L : Language} {n m k : } (σ₁ : L.Subst n m) (σ₂ : L.Subst m k) :
                            L.Subst n k

                            Composition of substitutions. Note: the direction is opposite to Function.comp.

                            Equations
                            Instances For

                              Composition of substitutions. Note: the direction is opposite to Function.comp.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                theorem FirstOrder.Language.Subst.comp_def {L : Language} {n m k : } {σ₁ : L.Subst n m} {σ₂ : L.Subst m k} :
                                σ₁ ∘ₛ σ₂ = of fun (i : Fin n) => (σ₁ i)[σ₂]ₜ
                                @[simp]
                                theorem FirstOrder.Language.Subst.comp_apply {L : Language} {n m k : } {σ₁ : L.Subst n m} {i : Fin n} {σ₂ : L.Subst m k} :
                                (σ₁ ∘ₛ σ₂) i = (σ₁ i)[σ₂]ₜ
                                theorem FirstOrder.Language.Term.subst_subst {L : Language} {n m k : } {t : L.Term n} {σ₁ : L.Subst n m} {σ₂ : L.Subst m k} :
                                t[σ₁]ₜ[σ₂]ₜ = t[σ₁ ∘ₛ σ₂]ₜ
                                theorem FirstOrder.Language.Subst.id_comp {L : Language} {n m : } {σ : L.Subst n m} :
                                idₛ ∘ₛ σ = σ
                                theorem FirstOrder.Language.Subst.comp_id {L : Language} {n m : } {σ : L.Subst n m} :
                                σ ∘ₛ idₛ = σ
                                theorem FirstOrder.Language.Subst.comp_assoc {L : Language} {n m k l : } {σ₁ : L.Subst n m} {σ₂ : L.Subst m k} {σ₃ : L.Subst k l} :
                                σ₁ ∘ₛ σ₂ ∘ₛ σ₃ = σ₁ ∘ₛ (σ₂ ∘ₛ σ₃)
                                theorem FirstOrder.Language.Subst.cons_comp {L : Language} {n m k : } {σ₁ : L.Subst n m} {t : L.Term m} {σ₂ : L.Subst m k} :
                                (t ∷ᵥ σ₁) ∘ₛ σ₂ = t[σ₂]ₜ ∷ᵥ σ₁ ∘ₛ σ₂
                                theorem FirstOrder.Language.Subst.append_comp {L : Language} {n m k l : } {σ₁ : L.Subst n m} {σ₂ : L.Subst k m} {σ₃ : L.Subst m l} :
                                (σ₁ ++ᵥ σ₂) ∘ₛ σ₃ = σ₁ ∘ₛ σ₃ ++ᵥ σ₂ ∘ₛ σ₃
                                theorem FirstOrder.Language.Subst.of_comp {L : Language} {n m k : } {v : Vec (L.Term m) n} {σ : L.Subst m k} :
                                of v ∘ₛ σ = of fun (i : Fin n) => (v i)[σ]ₜ
                                theorem FirstOrder.Language.Subst.of_cons {L : Language} {n m : } {t : L.Term m} {v : Vec (L.Term m) n} :
                                of (t ∷ᵥ v) = t ∷ᵥ of v
                                theorem FirstOrder.Language.Subst.of_append {L : Language} {n m k : } {v₁ : Vec (L.Term m) n} {v₂ : Vec (L.Term m) k} :
                                of (v₁ ++ᵥ v₂) = of v₁ ++ᵥ of v₂
                                def FirstOrder.Language.Subst.shift {L : Language} {n : } (k : ) :
                                L.Subst n (n + k)

                                Subst.shift k shifts variables from 0..n-1 to k..n-1+k.

                                Equations
                                Instances For
                                  theorem FirstOrder.Language.Subst.shift_def {L : Language} {n k : } :
                                  shift k = of fun (x : Fin n) => #(x.addNat k)
                                  @[simp]
                                  theorem FirstOrder.Language.Subst.shift_apply {L : Language} {n k : } {i : Fin n} :
                                  shift k i = #(i.addNat k)
                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For

                                    ↑ₜt is the abbreviation of t[Subst.shift 1]ₜ.

                                    Equations
                                    Instances For

                                      ↑ₜ^[k] t is the abbreviation of t[Subst.shift k]ₜ.

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          def FirstOrder.Language.Subst.embed {L : Language} {n : } (k : ) :
                                          L.Subst k (n + k)

                                          Subst.embed k keeps variables from 0..k-1 unchanged, but embeds them into L.Term (n + k).

                                          Equations
                                          Instances For
                                            theorem FirstOrder.Language.Subst.embed_def {L : Language} {n k : } :
                                            embed k = of fun (i : Fin k) => #(i.castAdd' n)
                                            @[simp]
                                            theorem FirstOrder.Language.Subst.embed_apply {L : Language} {n k : } {i : Fin k} :
                                            embed k i = #(i.castAdd' n)
                                            @[reducible, inline]
                                            abbrev FirstOrder.Language.Subst.single {L : Language} {n : } (t : L.Term n) :
                                            L.Subst (n + 1) n

                                            ↦ₛ t substitutes variable 0 to t and shifts remained variables i + 1 back to i. It is an abbreviation of t ∷ᵥ id.

                                            Equations
                                            Instances For

                                              ↦ₛ t substitutes variable 0 to t and shifts remained variables i + 1 back to i. It is an abbreviation of t ∷ᵥ id.

                                              Equations
                                              Instances For
                                                @[reducible, inline]
                                                abbrev FirstOrder.Language.Subst.assign {L : Language} {n : } (t : L.Term (n + 1)) :
                                                L.Subst (n + 1) (n + 1)

                                                ≔ₛ t is similar to ↦ₛ t, but only substitutes variable 0 and does not shift others. It is an abbreviation of t ∷ᵥ Subst.shift 1.

                                                Equations
                                                Instances For

                                                  ≔ₛ t is similar to ↦ₛ t, but only substitutes variable 0 and does not shift others. It is an abbreviation of t ∷ᵥ Subst.shift 1.

                                                  Equations
                                                  Instances For
                                                    @[reducible, inline]
                                                    abbrev FirstOrder.Language.Subst.lift {L : Language} {n m : } (k : ) (σ : L.Subst n m) :
                                                    L.Subst (n + k) (m + k)

                                                    ⇑ₛ^[k] σ keeps variables 0..k-1 unchanged and performs substitutions on remained variables as if 0..k-1 are all eliminated.

                                                    Equations
                                                    Instances For

                                                      ⇑ₛ^[k] σ keeps variables 0..k-1 unchanged and performs substitutions on remained variables as if 0..k-1 are all eliminated.

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

                                                        ⇑ₛσ is an abbreviation of ⇑ₛ^[1] σ.

                                                        Equations
                                                        Instances For
                                                          Equations
                                                          • One or more equations did not get rendered due to their size.
                                                          Instances For
                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              theorem FirstOrder.Language.Subst.shift_comp_cons {L : Language} {n m k : } {t : L.Term m} {σ : L.Subst (n + k) m} :
                                                              shift (k + 1) ∘ₛ (t ∷ᵥ σ) = shift k ∘ₛ σ
                                                              theorem FirstOrder.Language.Subst.shift_comp_append {L : Language} {n m k : } {σ₁ : L.Subst k m} {σ₂ : L.Subst n m} :
                                                              shift k ∘ₛ (σ₁ ++ᵥ σ₂) = σ₂
                                                              theorem FirstOrder.Language.Subst.embed_comp_append {L : Language} {n m k : } {σ₁ : L.Subst k m} {σ₂ : L.Subst n m} :
                                                              embed k ∘ₛ (σ₁ ++ᵥ σ₂) = σ₁
                                                              def FirstOrder.Language.Term.vars {L : Language} {n : } :
                                                              L.Term nSet (Fin n)
                                                              Equations
                                                              Instances For
                                                                theorem FirstOrder.Language.Term.subst_ext_vars {L : Language} {n m : } {t : L.Term n} {σ₁ σ₂ : L.Subst n m} (h : xt.vars, σ₁ x = σ₂ x) :
                                                                t[σ₁]ₜ = t[σ₂]ₜ
                                                                theorem FirstOrder.Language.Term.vars_subst {L : Language} {n m : } {t : L.Term n} {σ : L.Subst n m} :
                                                                t[σ]ₜ.vars = xt.vars, (σ x).vars

                                                                L.Formula n is the type of formulas with free variables indexed by Fin n.

                                                                Instances For

                                                                  A relation symbol applied by a vector of terms.

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

                                                                    Equality between two terms.

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

                                                                      Universal quantification of a formula.

                                                                      Equations
                                                                      • One or more equations did not get rendered due to their size.
                                                                      Instances For
                                                                        def FirstOrder.Language.Formula.ex {L : Language} {n : } (p : L.Formula (n + 1)) :

                                                                        Existential quantification of a formula. It is defined as ~ ∀' (~ p).

                                                                        Equations
                                                                        Instances For

                                                                          Existential quantification of a formula. It is defined as ~ ∀' (~ p).

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

                                                                            Conjunction of a vector of formulas.

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

                                                                              Pretty printer defined by notation3 command.

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

                                                                                Pretty printer defined by notation3 command.

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

                                                                                  Disjunction of a vector of formulas.

                                                                                  Equations
                                                                                  • One or more equations did not get rendered due to their size.
                                                                                  Instances For
                                                                                    def FirstOrder.Language.Formula.allN {L : Language} {n : } (k : ) :
                                                                                    L.Formula (n + k)L.Formula n

                                                                                    Universal quantification of a block of k variables.

                                                                                    Equations
                                                                                    Instances For

                                                                                      Universal quantification of a block of k variables.

                                                                                      Equations
                                                                                      • One or more equations did not get rendered due to their size.
                                                                                      Instances For
                                                                                        def FirstOrder.Language.Formula.exN {L : Language} {n : } (k : ) :
                                                                                        L.Formula (n + k)L.Formula n

                                                                                        Existential quantification of a block of k variables.

                                                                                        Equations
                                                                                        Instances For

                                                                                          Existential quantification of a block of k variables.

                                                                                          Equations
                                                                                          • One or more equations did not get rendered due to their size.
                                                                                          Instances For
                                                                                            @[simp]
                                                                                            theorem FirstOrder.Language.Formula.imp_eq {L : Language} {n : } {p q : L.Formula n} :
                                                                                            p.imp q = p q
                                                                                            @[simp]
                                                                                            theorem FirstOrder.Language.Formula.neg_eq {L : Language} {n : } {p : L.Formula n} :
                                                                                            p = ~ p
                                                                                            @[simp]
                                                                                            theorem FirstOrder.Language.Formula.imp_inj {L : Language} {n : } {p₁ q₁ p₂ q₂ : L.Formula n} :
                                                                                            p₁ q₁ = p₂ q₂ p₁ = p₂ q₁ = q₂
                                                                                            @[simp]
                                                                                            theorem FirstOrder.Language.Formula.neg_inj {L : Language} {n : } {p q : L.Formula n} :
                                                                                            ~ p = ~ q p = q
                                                                                            Equations
                                                                                            Instances For
                                                                                              @[simp]
                                                                                              @[irreducible]
                                                                                              instance FirstOrder.Language.Formula.decEq {L : Language} {n : } [(n : ) → DecidableEq (L.Func n)] [(n : ) → DecidableEq (L.Rel n)] :
                                                                                              Equations
                                                                                              • One or more equations did not get rendered due to their size.
                                                                                              def FirstOrder.Language.Formula.subst {L : Language} {n m : } :
                                                                                              L.Formula nL.Subst n mL.Formula m

                                                                                              Substitution of a formula.

                                                                                              Equations
                                                                                              Instances For

                                                                                                Substitution of a formula.

                                                                                                Equations
                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                Instances For
                                                                                                  Equations
                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                  Instances For
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_rel {L : Language} {n m k : } {σ : L.Subst n m} {r : L.Rel k} {v : Vec (L.Term n) k} :
                                                                                                    (r ⬝ʳ v)[σ]ₚ = r ⬝ʳ fun (i : Fin k) => (v i)[σ]ₜ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_eq {L : Language} {n m : } {σ : L.Subst n m} {t₁ t₂ : L.Term n} :
                                                                                                    (t₁ t₂)[σ]ₚ = t₁[σ]ₜ t₂[σ]ₜ
                                                                                                    @[simp]
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_imp {L : Language} {n m : } {σ : L.Subst n m} {p q : L.Formula n} :
                                                                                                    (p q)[σ]ₚ = p[σ]ₚ q[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_true {L : Language} {n m : } {σ : L.Subst n m} :
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_neg {L : Language} {n m : } {σ : L.Subst n m} {p : L.Formula n} :
                                                                                                    (~ p)[σ]ₚ = ~ p[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_and {L : Language} {n m : } {σ : L.Subst n m} {p q : L.Formula n} :
                                                                                                    (p q)[σ]ₚ = p[σ]ₚ q[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_or {L : Language} {n m : } {σ : L.Subst n m} {p q : L.Formula n} :
                                                                                                    (p q)[σ]ₚ = p[σ]ₚ q[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_iff {L : Language} {n m : } {σ : L.Subst n m} {p q : L.Formula n} :
                                                                                                    (p q)[σ]ₚ = p[σ]ₚ q[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_all {L : Language} {n m : } {σ : L.Subst n m} {p : L.Formula (n + 1)} :
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_ex {L : Language} {n m : } {σ : L.Subst n m} {p : L.Formula (n + 1)} :
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_vecAnd {L : Language} {n m k : } {σ : L.Subst n m} {v : Vec (L.Formula n) k} :
                                                                                                    ( (i : Fin k), v i)[σ]ₚ = (i : Fin k), (v i)[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_vecOr {L : Language} {n m k : } {σ : L.Subst n m} {v : Vec (L.Formula n) k} :
                                                                                                    ( (i : Fin k), v i)[σ]ₚ = (i : Fin k), (v i)[σ]ₚ
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_allN {L : Language} {n m k : } {σ : L.Subst n m} {p : L.Formula (n + k)} :
                                                                                                    @[simp]
                                                                                                    theorem FirstOrder.Language.Formula.subst_exN {L : Language} {n m k : } {σ : L.Subst n m} {p : L.Formula (n + k)} :
                                                                                                    theorem FirstOrder.Language.Formula.subst_subst {L : Language} {n m k : } {σ₁ : L.Subst n m} {p : L.Formula n} {σ₂ : L.Subst m k} :
                                                                                                    p[σ₁]ₚ[σ₂]ₚ = p[σ₁ ∘ₛ σ₂]ₚ
                                                                                                    Equations
                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                    Instances For
                                                                                                      @[simp]
                                                                                                      theorem FirstOrder.Language.Formula.subst_exUnique {L : Language} {n m : } {σ : L.Subst n m} {p : L.Formula (n + 1)} :

                                                                                                      ↑ₚp is the abbreviation of p[Subst.shift 1]ₚ.

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

                                                                                                        ↑ₚ^[k] p is the abbreviation of p[Subst.shift k]ₚ.

                                                                                                        Equations
                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                        Instances For
                                                                                                          Equations
                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                          Instances For
                                                                                                            Equations
                                                                                                            Instances For
                                                                                                              theorem FirstOrder.Language.Formula.subst_ext_free {L : Language} {n m : } {σ₁ σ₂ : L.Subst n m} {p : L.Formula n} :
                                                                                                              (∀ xp.free, σ₁ x = σ₂ x)p[σ₁]ₚ = p[σ₂]ₚ
                                                                                                              theorem FirstOrder.Language.Formula.free_subst {L : Language} {n m : } {σ : L.Subst n m} {p : L.Formula n} :
                                                                                                              p[σ]ₚ.free = xp.free, (σ x).vars
                                                                                                              @[reducible, inline]

                                                                                                              A sentence is a closed formula (formula with no free variables).

                                                                                                              Equations
                                                                                                              Instances For

                                                                                                                The universal closure of a formula.

                                                                                                                Equations
                                                                                                                Instances For
                                                                                                                  @[reducible, inline]

                                                                                                                  An abbreviation of Set (L.Formula n).

                                                                                                                  Equations
                                                                                                                  Instances For

                                                                                                                    append Γ p is the same as insert p Γ, but with a nicer notation Γ,' p so that when writing proofs, Γ,' p₁,' ⋯,' pₙ looks like a list of local hypotheses.

                                                                                                                    Equations
                                                                                                                    Instances For
                                                                                                                      Equations
                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                      Instances For
                                                                                                                        theorem FirstOrder.Language.FormulaSet.append_comm {L : Language} {n : } {Γ : L.FormulaSet n} {p q : L.Formula n} :
                                                                                                                        Γ,' p,' q = Γ,' q,' p
                                                                                                                        theorem FirstOrder.Language.FormulaSet.append_eq_append {L : Language} {n : } {Γ Δ : L.FormulaSet n} {p : L.Formula n} :
                                                                                                                        Γ = ΔΓ,' p = Δ,' p
                                                                                                                        theorem FirstOrder.Language.FormulaSet.subset_of_eq {L : Language} {n : } {Γ Δ : L.FormulaSet n} :
                                                                                                                        Γ = ΔΓ Δ
                                                                                                                        theorem FirstOrder.Language.FormulaSet.mem_append {L : Language} {n : } {Γ : L.FormulaSet n} {p : L.Formula n} :
                                                                                                                        p Γ,' p
                                                                                                                        theorem FirstOrder.Language.FormulaSet.append_subset_append {L : Language} {n : } {Γ Δ : L.FormulaSet n} {p : L.Formula n} :
                                                                                                                        Γ ΔΓ,' p Δ,' p
                                                                                                                        def FirstOrder.Language.FormulaSet.shift {L : Language} {n : } (k : ) (Γ : L.FormulaSet n) :
                                                                                                                        L.FormulaSet (n + k)
                                                                                                                        Equations
                                                                                                                        Instances For
                                                                                                                          Equations
                                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                                          Instances For
                                                                                                                            @[simp]
                                                                                                                            @[simp]
                                                                                                                            @[reducible, inline]

                                                                                                                            A theory is a set of sentences, as the axioms of the theory (not the deductive closure).

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