Logical Entities

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
Logical Entities — Kireth Semantic Library
Version: 1.0 | Locale: en-GB | Date: 2026-10-14
Authors: Mark Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/logical-entities.html
Status: Proposed formalisation; source page wording not independently verified.

flow "LogicalEntities" v1.0

ONTOLOGY:
  id: kireth:logical-entities
  domain: mathematical-entities/logical-entities
  label: Logical Entities
  definition: Typed entities used to represent propositions, logical formulas, interpretations, proofs, and inference.

TYPES:
  TruthValue := {TRUE, FALSE}
  Proposition := well_formed_declarative_formula
  AtomicProposition <: Proposition
  CompoundProposition <: Proposition
  Predicate := relation_symbol_with_arity
  Term := Variable | Constant | FunctionApplication
  Formula := AtomicFormula | Negation | Conjunction | Disjunction | Implication | Biconditional | QuantifiedFormula
  LogicalConnective := NOT | AND | OR | IMPLIES | IFF
  Quantifier := FOR_ALL | EXISTS
  Interpretation := assignment_of_meaning_to_symbols
  Model := Interpretation satisfying FormulaSet
  Premise := Formula
  Conclusion := Formula
  InferenceRule := sound_syntactic_transformation
  Proof := finite_sequence_of_justified_formulas
  Theory := set_of_formulas
  LogicalRelationship := Entails | Equivalent | Contradicts | ConsistentWith | DependsOn

SIGNATURE:
  not: Proposition -> Proposition
  and: Proposition x Proposition -> Proposition
  or: Proposition x Proposition -> Proposition
  implies: Proposition x Proposition -> Proposition
  iff: Proposition x Proposition -> Proposition
  forall: Variable x Formula -> Formula
  exists: Variable x Formula -> Formula
  entails: FormulaSet x Formula -> Boolean
  proves: Theory x Formula -> Boolean
  satisfies: Interpretation x Formula -> Boolean

AXIOMS:
  A1: not(TRUE) = FALSE; not(FALSE) = TRUE
  A2: and(p,q) = TRUE iff p = TRUE and q = TRUE
  A3: or(p,q) = TRUE iff p = TRUE or q = TRUE
  A4: implies(p,q) = not(p) or q
  A5: iff(p,q) = and(implies(p,q), implies(q,p))
  A6: forall(x,P(x)) holds iff P(a) holds for every a in the specified domain
  A7: exists(x,P(x)) holds iff P(a) holds for at least one a in the specified domain
  A8: Gamma entails phi iff every model of Gamma satisfies phi
  A9: Gamma proves phi iff phi has a derivation from Gamma under the chosen proof calculus

INFERENCE_RULES:
  R1_MODUS_PONENS: from p and implies(p,q), derive q
  R2_MODUS_TOLLENS: from implies(p,q) and not(q), derive not(p)
  R3_CONJUNCTION_INTRO: from p and q, derive and(p,q)
  R4_CONJUNCTION_ELIM: from and(p,q), derive p; derive q
  R5_UNIVERSAL_ELIM: from forall(x,P(x)), derive P(t) for a well-typed substitutable term t
  R6_EXISTENTIAL_INTRO: from P(t), derive exists(x,P(x))
  R7_DOUBLE_NEGATION: in classical logic, not(not(p)) is equivalent to p

RELATIONSHIPS:
  Proposition --HAS_TRUTH_VALUE--> TruthValue [under an interpretation]
  CompoundProposition --USES--> LogicalConnective
  QuantifiedFormula --BINDS--> Variable
  Formula --EVALUATED_UNDER--> Interpretation
  Interpretation --SATISFIES--> Formula
  Proof --DERIVES--> Conclusion
  InferenceRule --TRANSFORMS--> PremiseSet
  Theory --ENTAILS--> Formula
  Formula --SEMANTICALLY_EQUIVALENT_TO--> Formula

SEMANTIC_EQUIVALENCE:
  classical: not(and(p,q)) <=> or(not(p),not(q))
  classical: not(or(p,q)) <=> and(not(p),not(q))
  classical: implies(p,q) <=> or(not(p),q)
  caveat: Equivalences depend on the specified logic; do not transfer classical identities unconditionally to intuitionistic, paraconsistent, or many-valued systems.

CONSTRAINTS:
  C1: Every predicate application must respect its declared arity and argument types.
  C2: Bound and free variables must be distinguished; substitutions must avoid variable capture.
  C3: Syntactic provability and semantic entailment are distinct relations.
  C4: Truth values must not be confused with confidence scores or probabilities.
  C5: A contradiction does not imply arbitrary conclusions outside explosive logics.
  C6: Domain, logic family, and interpretation must be declared for quantified evaluations.

VALIDATION:
  - parse formulas and verify type correctness
  - verify quantifier scope and safe substitution
  - test propositional equivalences using truth tables in classical mode
  - verify proof steps against named inference rules
  - verify semantic claims against declared interpretations/models
  - reject cross-logic inferences without explicit translation assumptions

CONFIDENCE:
  field: confidence
  type: real[0,1]
  meaning: epistemic confidence in a claim or extraction, not a logical truth value
  provenance_required: true

FLOW_HASH:
  algorithm: SHA-256
  input: canonical_UTF8(ontology_id, version, types, axioms, rules, relationships, constraints)
  note: Compute the digest at ingestion; no digest is asserted in this document.

UPDATE_MODEL:
  strategy: versioned_append_with_deprecation
  on_change: revalidate_dependents; recompute_flow_hash; preserve_provenance

AI_CONSUMPTION:
  representation: typed_knowledge_graph_and_rule_set
  required: [ontology_id, logic_family, formula, signature, provenance]
  operations: [parse, typecheck, normalise, infer, validate, explain]
  guardrails: [no_unjustified_entailment, distinguish_syntax_from_semantics, declare_assumptions]
  output: {conclusion, supporting_premises, applied_rules, assumptions, confidence, provenance}

END FLOW ALGEBRA