Logical Connective Ontology

FLOW ALGEBRA
LOGICAL CONNECTIVE ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Logical Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/logical-entities/logical-connective-ontology-3.html
Version: 1.0 | Locale: en-GB | Status: proposed formalisation; source page not independently verified
Authors: Mark Higgins — Sky (Recursive AI)

1. ONTOLOGY IDENTITY
flow "LogicalConnectiveOntology" v1.0
namespace: kireth.semantic_library.mathematical_entities.logical_entities
entity: LogicalConnective
parent: LogicalEntity
purpose: Represent truth-functional operators, their arity, semantics, algebraic laws and valid inference transformations.

2. TYPED ENTITIES
TruthValue := {FALSE, TRUE}
Formula := Atomic(name) | Apply(connective: LogicalConnective, arguments: Formula[])
Valuation := mapping AtomicName -> TruthValue
LogicalConnective := {symbol: str, arity: int, truth_function: TruthValue^arity -> TruthValue}
UnaryConnective <: LogicalConnective
BinaryConnective <: LogicalConnective
DerivedConnective <: LogicalConnective

3. CANONICAL CONNECTIVES
NOT(p) := !p
AND(p,q) := p && q
OR(p,q) := p || q             # inclusive OR
IMPLIES(p,q) := (!p) || q
IFF(p,q) := (p && q) || ((!p) && (!q))
XOR(p,q) := (p || q) && !(p && q)
NAND(p,q) := !(p && q)
NOR(p,q) := !(p || q)
TRUE_CONST := TRUE
FALSE_CONST := FALSE

4. TRUTH TABLES
p q | NOT p | AND | OR | IMPLIES | IFF | XOR | NAND | NOR
F F | T     | F   | F  | T       | T   | F   | T    | T
F T | T     | F   | T  | T       | F   | T   | T    | F
T F | F     | F   | T  | F       | F   | T   | T    | F
T T | F     | T   | T  | T       | T   | F   | F    | F

5. EVALUATION SEMANTICS
EVAL(Atomic(x), valuation) := valuation[x]
EVAL(Apply(c,args), valuation) := c.truth_function(map(EVAL(_,valuation),args))
WELL_FORMED(Apply(c,args)) := length(args) == c.arity AND all(WELL_FORMED,args)
EQUIVALENT(phi,psi) := forall valuation: EVAL(phi,valuation) == EVAL(psi,valuation)
TAUTOLOGY(phi) := forall valuation: EVAL(phi,valuation) == TRUE
CONTRADICTION(phi) := forall valuation: EVAL(phi,valuation) == FALSE
SATISFIABLE(phi) := exists valuation: EVAL(phi,valuation) == TRUE

6. ALGEBRAIC IDENTITIES (CLASSICAL TWO-VALUED LOGIC)
COMMUTATIVITY: p AND q == q AND p; p OR q == q OR p
ASSOCIATIVITY: (p AND q) AND r == p AND (q AND r); likewise OR
DISTRIBUTIVITY: p AND (q OR r) == (p AND q) OR (p AND r)
DUAL_DISTRIBUTIVITY: p OR (q AND r) == (p OR q) AND (p OR r)
IDENTITY: p AND TRUE == p; p OR FALSE == p
DOMINATION: p OR TRUE == TRUE; p AND FALSE == FALSE
IDEMPOTENCE: p AND p == p; p OR p == p
COMPLEMENT: p AND NOT p == FALSE; p OR NOT p == TRUE
DOUBLE_NEGATION: NOT NOT p == p
DE_MORGAN: NOT(p AND q) == NOT p OR NOT q; NOT(p OR q) == NOT p AND NOT q
ABSORPTION: p OR (p AND q) == p; p AND (p OR q) == p
IMPLICATION_ELIMINATION: p IMPLIES q == NOT p OR q
CONTRAPOSITION: p IMPLIES q == NOT q IMPLIES NOT p
BICONDITIONAL: p IFF q == (p IMPLIES q) AND (q IMPLIES p)

7. RELATIONSHIPS
LogicalConnective --OPERATES_ON--> Formula
LogicalConnective --RETURNS--> TruthValue
LogicalConnective --HAS_ARITY--> NonNegativeInteger
LogicalConnective --HAS_TRUTH_FUNCTION--> TruthFunction
Formula --EVALUATED_UNDER--> Valuation
Formula --SEMANTICALLY_EQUIVALENT_TO--> Formula
AND --DUAL_OF--> OR
NAND --NEGATION_OF--> AND
NOR --NEGATION_OF--> OR
IMPLIES --DEFINABLE_BY--> {NOT, OR}

8. EXECUTABLE INFERENCE FLOWS
flow EvaluateFormula(phi, valuation):
  require WELL_FORMED(phi)
  require all atoms in phi have assignments in valuation
  return EVAL(phi, valuation)

flow CheckEquivalence(phi, psi):
  require WELL_FORMED(phi) AND WELL_FORMED(psi)
  atoms := union(ATOMS(phi), ATOMS(psi))
  for each valuation in ALL_BOOLEAN_ASSIGNMENTS(atoms):
    if EVAL(phi,valuation) != EVAL(psi,valuation):
      return {equivalent:false, counterexample:valuation}
  return {equivalent:true}

flow ModusPonens(p, q, valuation):
  require EVAL(p,valuation) == TRUE
  require EVAL(IMPLIES(p,q),valuation) == TRUE
  infer EVAL(q,valuation) == TRUE

flow Simplify(phi):
  apply sound classical equivalence rewrites
  preserve EQUIVALENT(input,output)
  return output

9. SEMANTIC DISTINCTIONS
AND requires both operands true; inclusive OR requires at least one true.
XOR requires exactly one operand true.
Material implication is false only when antecedent is true and consequent false; it does not itself express causality.
Logical equivalence is equality of truth under every valuation; syntactic identity is equality of expressions.
A logical connective is an operator; a proposition is a formula that the operator may combine.
Truth-functional semantics are distinct from modal, intuitionistic, fuzzy and paraconsistent semantics; do not transfer classical laws without a specified logic.

10. VALIDATION
CHECK arity and argument types for every connective application.
CHECK every truth table has 2^arity rows and deterministic outputs.
CHECK declared rewrites by exhaustive valuation for finite atomic signatures.
CHECK implication, equivalence and negation are not confused with metadata relations.
CHECK scope, parentheses and precedence before evaluating expressions.
CHECK inference results preserve stated assumptions and logic system.

11. CONFIDENCE AND SEMANTIC EQUIVALENCE
CONFIDENCE: 1.0 for formally truth-table-verified identities within classical Boolean logic; otherwise evidence-dependent.
SEMANTIC_EQUIVALENCE: determined by matching truth values for all valuations in the declared semantics.
No empirical confidence score is a substitute for a logical proof.

12. FLOW HASH AND UPDATE MODEL
FLOW_HASH := SHA256(canonical_UTF8(normalise(namespace,version,types,axioms,rules,semantics)))
Note: FLOW_HASH is a reproducible specification, not a precomputed digest.
UPDATE_MODEL: semantic_versioning; invalidate hash and dependent derivations when definitions or inference rules change.

13. AI CONSUMPTION
AI_CONSUMPTION:
  parsing: typed abstract syntax trees
  reasoning: truth-table evaluation and sound rewrites
  retrieval: connectives, definitions, truth tables and equivalence rules
  provenance: retain source URL, version, author credit and validation status
  safety: distinguish proved statements from conjectures or informal paraphrases
  output: machine-readable triples, canonical formulas, validation reports

END FLOW ALGEBRA