Predicate Logic Ontology

FLOW ALGEBRA
TITLE: Predicate Logic Ontology
DOMAIN: Discrete Mathematics / Logic / First-Order Predicate Logic
SOURCE_URL: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/logic/predicate-logic-ontology-2.html
VERSION: 1.0
LANGUAGE: en-GB
AUTHORSHIP: Mark Higgins — Sky (Recursive AI)
PROJECT: Kireth Semantic Library | https://kirethresearch.org
STATUS: Mathematical model; source page content not independently verified

1. PURPOSE
Represent first-order predicate logic through typed syntax, semantic interpretation, quantification, substitution, entailment, and mechanically checkable reasoning constraints.

2. TYPED ENTITIES
Sort := nonempty domain type
Variable := symbol with assigned Sort
Constant := symbol denoting an element of a Sort
FunctionSymbol := (Sort_1,...,Sort_n) -> Sort_out
PredicateSymbol := (Sort_1,...,Sort_n) -> Bool
Term := Variable | Constant | FunctionSymbol(Term_1,...,Term_n)
Formula := Atomic | Not | And | Or | Implies | Iff | ForAll | Exists
Atomic := PredicateSymbol(Term_1,...,Term_n) | Equality(Term,Term)
Interpretation := (Domains, ConstantDenotations, FunctionDenotations, PredicateExtensions)
Assignment := Variable -> DomainElement
Theory := Set[Sentence]
Sentence := Formula with no free variables
Proof := finite sequence of justified formulae

3. FORMATION RULES
WELL_TYPED(P(t1,...,tn)) iff each ti has the declared argument sort.
WELL_TYPED(f(t1,...,tn)) iff each ti matches the input sort and output is declared.
WELL_FORMED(¬φ), WELL_FORMED(φ∧ψ), WELL_FORMED(φ∨ψ), WELL_FORMED(φ→ψ), WELL_FORMED(φ↔ψ) when operands are formulae.
WELL_FORMED(∀x:Sort φ), WELL_FORMED(∃x:Sort φ) when x is a typed variable and φ a formula.
Equality is permitted only between terms of the same sort.

4. SEMANTIC EVALUATION
EVAL(t, I, g) := denotation of term t under interpretation I and assignment g.
SAT(I,g,P(t1,...,tn)) iff (EVAL(t1,I,g),...,EVAL(tn,I,g)) belongs to I(P).
SAT(I,g,t1=t2) iff EVAL(t1,I,g)=EVAL(t2,I,g).
SAT(I,g,¬φ) iff not SAT(I,g,φ).
SAT(I,g,φ∧ψ) iff SAT(I,g,φ) and SAT(I,g,ψ).
SAT(I,g,φ∨ψ) iff SAT(I,g,φ) or SAT(I,g,ψ).
SAT(I,g,φ→ψ) iff not SAT(I,g,φ) or SAT(I,g,ψ).
SAT(I,g,φ↔ψ) iff SAT(I,g,φ) equals SAT(I,g,ψ).
SAT(I,g,∀x:S φ) iff for every d in I(S), SAT(I,g[x:=d],φ).
SAT(I,g,∃x:S φ) iff for some d in I(S), SAT(I,g[x:=d],φ).
MODEL(I,T) iff every sentence in T is true under I.
ENTAILS(T,φ) iff every model of T satisfies sentence φ.

5. QUANTIFIER LAWS
¬∀x φ ≡ ∃x ¬φ
¬∃x φ ≡ ∀x ¬φ
∀x(φ∧ψ) ≡ (∀x φ)∧(∀x ψ)
∃x(φ∨ψ) ≡ (∃x φ)∨(∃x ψ)
∀x φ ≡ φ and ∃x φ ≡ φ if x is not free in φ and its sort is nonempty.
Quantifier order is not generally interchangeable: ∀x∃y R(x,y) does not entail ∃y∀x R(x,y).
Variable renaming preserves meaning only under capture-avoiding alpha conversion.

6. INFERENCE RULES
UNIVERSAL_ELIMINATION: from ∀x φ derive φ[t/x] when t is free for x in φ.
UNIVERSAL_INTRODUCTION: from φ derive ∀x φ only when x is not free in any undischarged assumption.
EXISTENTIAL_INTRODUCTION: from φ[t/x] derive ∃x φ when substitution is valid.
EXISTENTIAL_ELIMINATION: from ∃x φ, reason with a fresh witness symbol and discharge the witness assumption without leaking it into the conclusion.
MODUS_PONENS: from φ and φ→ψ derive ψ.
EQUALITY_REFLEXIVITY: t=t.
EQUALITY_SUBSTITUTION: equal terms may be substituted in well-typed formulae without variable capture.
SOUNDNESS: if T ⊢ φ under sound proof rules, then T ⊨ φ.
COMPLETENESS: in classical first-order logic, if T ⊨ φ, then T ⊢ φ.

7. RELATIONSHIPS
PredicateLogic IS_A FormalLogic.
FirstOrderLogic EXTENDS PropositionalLogic.
Predicate APPLIES_TO Tuple[DomainElement].
Quantifier BINDS Variable.
Formula HAS_FREE_VARIABLE Variable.
Interpretation ASSIGNS_MEANING_TO Symbol.
Theory ENTAILS Sentence when true in every model.
Proof DERIVES Formula by inference rules.
PredicateLogic SUPPORTS OntologyAxioms, KnowledgeRepresentation, FormalVerification.

8. FLOW OPERATIONS
PARSE(source) -> AbstractSyntaxTree | SyntaxError
TYPE_CHECK(ast, signature) -> TypedFormula | TypeError
FREE_VARIABLES(formula) -> Set[Variable]
SUBSTITUTE(formula, x, term) -> Formula; capture-avoiding
ALPHA_NORMALISE(formula) -> Formula
EVALUATE(formula, interpretation, assignment) -> Bool
CHECK_MODEL(theory, interpretation) -> Bool
PROVE(theory, conjecture) -> Proof | Unknown
FIND_COUNTERMODEL(theory, conjecture) -> Interpretation | Unknown
NORMALISE(formula, target_form) -> EquivalentFormula; preserve first-order semantics

9. VALIDATION
V1: Every term and predicate argument has a declared, compatible sort.
V2: All bound-variable scopes are explicit; no unintended capture.
V3: Formula equivalence is verified over the intended interpretation class.
V4: Quantifier introduction and elimination satisfy side conditions.
V5: Nonempty sorts are assumed; alternative empty-domain semantics require explicit rules.
V6: Proof steps have cited premises and an applicable sound inference rule.
V7: Distinguish syntactic derivability (⊢) from semantic entailment (⊨).
V8: General first-order validity is semi-decidable, not decidable in full generality; solver timeouts mean Unknown, not False.
V9: Inconsistency checks are explicit: classical inconsistent theories entail every formula.

10. SEMANTIC_EQUIVALENCE
SEMANTIC_EQUIVALENCE(φ,ψ,context) := for all admissible interpretations I and assignments g, SAT(I,g,φ) iff SAT(I,g,ψ).
ALPHA_EQUIVALENCE := identical up to consistent renaming of bound variables.
Do not conflate logical equivalence, syntactic equality, and equisatisfiability.

11. CONFIDENCE
CONFIDENCE.kind := {proved, model_checked, empirically_supported, unverified, refuted, unknown}
CONFIDENCE.proved requires a verified derivation under declared logic and axioms.
CONFIDENCE.model_checked is scoped to enumerated finite models or solver assumptions.
CONFIDENCE must not be fabricated as a numeric probability of mathematical truth.

12. FLOW_HASH
FLOW_HASH.algorithm := SHA-256
FLOW_HASH.input := canonical UTF-8 serialization of version, signature, axioms, inference rules, and semantic constraints.
FLOW_HASH.value := COMPUTE_AT_INGESTION
Do not treat the placeholder as an actual digest.

13. UPDATE_MODEL
UPDATE_MODEL.trigger := change to signature, axiom set, rule set, semantics, or source revision.
UPDATE_MODEL.steps := validate -> version -> canonicalise -> recompute hash -> rerun proofs -> record provenance.
UPDATE_MODEL.compatibility := flag changes affecting existing derived claims.

14. AI_CONSUMPTION
AI_CONSUMPTION.mode := typed, provenance-aware logical retrieval and inference.
AI_CONSUMPTION.inputs := signature, formulae, theory, interpretation constraints.
AI_CONSUMPTION.outputs := parsed formulae, proof traces, countermodels, or explicit unknown status.
AI_CONSUMPTION.guardrails := preserve quantifier scope; enforce typing; do not assert proof without derivation; surface assumptions and solver limits.

15. EXAMPLE
Sort: Person
Predicate: Human(Person), Mortal(Person)
Constant: socrates : Person
Axiom 1: ∀x:Person (Human(x) → Mortal(x))
Axiom 2: Human(socrates)
Inference: Universal elimination on Axiom 1, then modus ponens with Axiom 2.
Conclusion: Mortal(socrates)

END FLOW ALGEBRA