Logic

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

FLOW ALGEBRA
TITLE: Logic — Discrete Mathematics Ontologies
SOURCE_URL: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/logic.html
VERSION: 1.0
DOMAIN: Discrete Mathematics / Mathematical Logic
SCOPE: Foundational parent-page ontology
AUTHORSHIP: Mark Higgins — Sky (Recursive AI)
SITE: https://kirethresearch.org

1. ONTOLOGY DECLARATION
ontology Logic {
  entities: Proposition, TruthValue, Formula, Variable, Connective, Interpretation,
            Valuation, InferenceRule, Argument, Proof, Model, Predicate, Quantifier,
            Domain, KnowledgeBase, Constraint;
  branches: PropositionalLogic, PredicateLogic, BooleanLogic, FormalProof,
            LogicalEquivalence, Satisfiability, Entailment;
}

2. TYPES AND SIGNATURES
TruthValue := {TRUE, FALSE}
Proposition := well_formed_formula with truth value under a valuation
Variable := atomic propositional symbol | bound/free predicate variable
Connective := NOT | AND | OR | IMPLIES | IFF
Formula := Atom | NOT(Formula) | Binary(Connective, Formula, Formula)
Valuation : PropositionVariable -> TruthValue
Interpretation : (Domain, SymbolAssignments)
Entailment : Set[Formula] x Formula -> Boolean
Proof : (Assumptions, OrderedInferenceSteps, Conclusion)

3. CORE SEMANTICS
NOT(p)          := ¬p
AND(p,q)        := p ∧ q
OR(p,q)         := p ∨ q
IMPLIES(p,q)    := ¬p ∨ q
IFF(p,q)        := (p → q) ∧ (q → p)
TAUTOLOGY(p)    := ∀v : Eval(p,v) = TRUE
CONTRADICTION(p):= ∀v : Eval(p,v) = FALSE
SATISFIABLE(p)  := ∃v : Eval(p,v) = TRUE
EQUIVALENT(p,q) := ∀v : Eval(p,v) = Eval(q,v)
ENTAILS(Γ,p)    := ∀v : (∀g∈Γ Eval(g,v)=TRUE) ⇒ Eval(p,v)=TRUE

4. ALGEBRAIC LAWS
DoubleNegation: ¬¬p ≡ p
CommutativeAnd: p∧q ≡ q∧p
CommutativeOr: p∨q ≡ q∨p
AssociativeAnd: (p∧q)∧r ≡ p∧(q∧r)
AssociativeOr: (p∨q)∨r ≡ p∨(q∨r)
DistributiveAnd: p∧(q∨r) ≡ (p∧q)∨(p∧r)
DistributiveOr: p∨(q∧r) ≡ (p∨q)∧(p∨r)
DeMorganAnd: ¬(p∧q) ≡ ¬p∨¬q
DeMorganOr: ¬(p∨q) ≡ ¬p∧¬q
ExcludedMiddle: p∨¬p ≡ TRUE
NonContradiction: p∧¬p ≡ FALSE
IdentityAnd: p∧TRUE ≡ p
IdentityOr: p∨FALSE ≡ p
AbsorptionAnd: p∧(p∨q) ≡ p
AbsorptionOr: p∨(p∧q) ≡ p

5. PREDICATE LOGIC
Predicate(P, n) : Domain^n -> TruthValue
FORALL(x, P(x)) := ∀x∈Domain P(x)
EXISTS(x, P(x)) := ∃x∈Domain P(x)
QuantifierNegation1: ¬∀x P(x) ≡ ∃x ¬P(x)
QuantifierNegation2: ¬∃x P(x) ≡ ∀x ¬P(x)
QuantifierScope: preserve binding and variable capture constraints

6. INFERENCE RULES
ModusPonens: (p, p→q) |- q
ModusTollens: (¬q, p→q) |- ¬p
ConjunctionIntroduction: (p,q) |- p∧q
ConjunctionElimination: p∧q |- p
DisjunctionIntroduction: p |- p∨q
UniversalInstantiation: ∀x P(x) |- P(t), where t is admissible
ExistentialGeneralisation: P(t) |- ∃x P(x)
SoundnessRequirement: every inference step preserves semantic entailment

7. SEMANTIC RELATIONSHIPS
Logic IS_A FormalSystemDomain
PropositionalLogic SUBDOMAIN_OF Logic
PredicateLogic EXTENDS PropositionalLogic
BooleanAlgebra MODELS ClassicalPropositionalConnectives
Formula EVALUATED_UNDER Valuation
InferenceRule TRANSFORMS Premises TO Conclusion
Proof ESTABLISHES Derivability
Model SATISFIES Formula
KnowledgeBase CONTAINS Formula
LogicalEquivalence RELATES Formula TO Formula

8. FLOW EXECUTION
flow LogicReasoning(input: Set[Formula], query: Formula):
  parse(input, query) -> AST
  typecheck(AST) -> WellFormedAST
  normalise(WellFormedAST) -> CanonicalFormula
  validate_assumptions(input) -> ConsistencyReport
  derive(input, query) -> ProofAttempt
  model_check(input, query) -> EntailmentResult
  emit(ProofAttempt, EntailmentResult, Provenance, Confidence)

9. VALIDATION
assert NOT(TRUE) = FALSE
assert AND(TRUE,FALSE) = FALSE
assert OR(TRUE,FALSE) = TRUE
assert IMPLIES(FALSE,FALSE) = TRUE
assert EQUIVALENT(p→q, ¬p∨q)
assert ENTAILS({p,p→q},q)
assert NOT ENTAILS({p∨q},p)
assert SATISFIABLE(p∨q)
assert NOT SATISFIABLE(p∧¬p)
check variable binding, arity, proof steps, interpretation domain, and assumptions

10. SEMANTIC_EQUIVALENCE
method: truth_table | logical_rewrite | theorem_prover
scope: classical two-valued logic unless a different semantics is declared
require: identical truth under every admissible valuation or interpretation

11. CONFIDENCE
mathematical_theorem: 1.0 when formally proved under stated assumptions
verified_model_check: 1.0 within fully enumerated finite interpretation
heuristic_inference: calibrated estimate; never represent as formal certainty
unknown_or_unverified: null

12. FLOW_HASH
algorithm: SHA-256
input: canonicalised ontology declaration + rules + source URL + version
output: computed at publication; no fabricated digest

13. UPDATE_MODEL
revision: 1.0
triggers: changed axioms, scope, inference rules, semantic interpretation, or source
requirements: preserve provenance; rerun validation; recompute FLOW_HASH

14. AI_CONSUMPTION
formats: UTF-8 TXT; convertible to JSON-LD/RDF with explicit mappings
uses: symbolic reasoning, theorem proving, knowledge graphs, rule engines,
      formal verification, AI retrieval and semantic alignment
constraints: distinguish syntax from semantics; classical from nonclassical logic;
             derivability from entailment; proofs from heuristic predictions

15. PROVENANCE AND LIMITATIONS
This is a mathematically grounded foundational flow for the supplied page URL.
Live page content was not independently verified; do not infer page-specific claims.