Conditional Statement Ontology

FLOW ALGEBRA
CONDITIONAL STATEMENT ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Equation and Statement Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/conditional-statement-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Status: Mathematical specification; source-page wording not independently verified.

01. PURPOSE
flow "ConditionalStatementOntology" v1.0
  domain: mathematical_logic
  entity_type: ConditionalStatement
  intent: represent, type-check, interpret, evaluate and reason over conditional statements
  notation: P -> Q (material implication unless another interpretation is specified)

02. ENTITY MODEL
entity ConditionalStatement {
  id: URI
  antecedent: Proposition
  consequent: Proposition
  connective: ImplicationOperator
  semantics: {material, intuitionistic, strict, causal, probabilistic, rule_based}
  context: Context
  assumptions: Set[Proposition]
  variable_bindings: Map[Variable, Domain]
  proof_status: {proved, disproved, assumed, conjectured, undecided, unknown}
  provenance: SourceReference
  confidence: ConfidenceRecord
}

03. TYPED RELATIONS
ConditionalStatement --hasAntecedent--> Proposition
ConditionalStatement --hasConsequent--> Proposition
ConditionalStatement --usesConnective--> ImplicationOperator
ConditionalStatement --dependsOn--> Assumption
ConditionalStatement --interpretedUnder--> Semantics
ConditionalStatement --hasProof--> Proof
ConditionalStatement --hasCounterexample--> Counterexample
ConditionalStatement --equivalentUnderClassicalLogic--> Disjunction

04. CORE DEFINITION
material_implication(P,Q) := NOT P OR Q
truth_table:
  P=true,  Q=true  => true
  P=true,  Q=false => false
  P=false, Q=true  => true
  P=false, Q=false => true
note: material implication does not by itself establish causation or relevance.

05. SYNTAX AND PARSING
parse: "if P then Q" -> implies(P,Q)
parse: "P only if Q" -> implies(P,Q)
parse: "P if Q" -> implies(Q,P)
parse: "P is sufficient for Q" -> implies(P,Q)
parse: "Q is necessary for P" -> implies(P,Q)
parse: "P iff Q" -> iff(P,Q)
precedence: NOT > AND > OR > IMPLIES > IFF
validation: parentheses override precedence; ambiguity must be resolved before inference.

06. DERIVED FORMS
converse(P->Q) := Q->P
inverse(P->Q) := NOT P -> NOT Q
contrapositive(P->Q) := NOT Q -> NOT P
classical_equivalence: (P->Q) <=> (NOT Q -> NOT P)
warning: converse and inverse are not generally equivalent to the original conditional.

07. INFERENCE RULES
modus_ponens: from P and (P->Q), infer Q
modus_tollens: from NOT Q and (P->Q), infer NOT P
hypothetical_syllogism: from (P->Q) and (Q->R), infer (P->R)
conditional_proof: if assuming P permits derivation of Q, discharge P and infer P->Q
invalid_affirming_consequent: (P->Q), Q |- P  [REJECT]
invalid_denying_antecedent: (P->Q), NOT P |- NOT Q [REJECT]

08. QUANTIFICATION AND SCOPE
universal_conditional: FORALL x in D: P(x) -> Q(x)
existential_conditional: EXISTS x in D: P(x) -> Q(x)
warning: existential conditional may be vacuously true for a witness where P(x) is false.
free_variables: identify before assigning a truth value to an open formula.
variable_capture: reject substitutions that capture free variables.

09. MATHEMATICAL EXAMPLES
example_1:
  statement: FORALL n in Z: divisible(n,4) -> even(n)
  status: valid
example_2:
  statement: FORALL x in R: x>2 -> x>1
  status: valid
example_3:
  statement: FORALL x in R: x^2=4 -> x=2
  status: false
  counterexample: x=-2
example_4:
  statement: FORALL x in R: x!=0 -> x/x=1
  status: valid
  domain_constraint: x!=0

10. DOMAIN AND PRECONDITIONS
check antecedent/consequent are well-formed propositions.
check operators are defined for operand types.
check domain restrictions (division by zero, roots, logarithms).
check all assumptions used in a proof are declared.
check semantics before applying classical equivalence laws.

11. CONDITIONAL CLASSIFICATION
material: truth-functional P->Q
strict: necessity of implication in a modal frame
intuitionistic: constructive transformation from proof(P) to proof(Q)
causal: intervention-sensitive causal relationship, not inferred from P->Q alone
probabilistic: conditional probability P(Q|P), defined when P(P)>0
rule_based: antecedent matches trigger and consequent denotes rule outcome
constraint: consequent required when antecedent holds

12. SEMANTIC EQUIVALENCE
under_classical_logic:
  implies(P,Q) == or(not(P),Q)
  implies(P,Q) == implies(not(Q),not(P))
  not(implies(P,Q)) == and(P,not(Q))
  implies(P,and(Q,R)) == and(implies(P,Q),implies(P,R))
normalise: canonical AST + explicit scope + domain + semantics
avoid: conflating logically equivalent formulas with identical provenance or explanatory meaning.

13. KNOWLEDGE GRAPH
node: conditional_statement
edges: antecedent, consequent, context, assumption, proof, counterexample
identity_key: canonical_form + semantics + bound_variable_normalisation + domain
link_to: MathematicalStatement, MathematicalRule, ImplicationRelationship, LogicalInference
query: find all implications whose antecedent matches known facts
query: find counterexamples to a universal implication

14. EXECUTION PIPELINE
input -> parse -> resolve_symbols -> type_check -> establish_domain
      -> select_semantics -> normalise -> validate_assumptions
      -> evaluate_or_prove -> record_result -> publish_graph

15. EVALUATION MODEL
if semantics=material and P,Q are closed and truth-valued:
  return (not evaluate(P)) or evaluate(Q)
if open_formula:
  require assignment or quantifier closure
if symbolic:
  use sound proof rules; UNKNOWN is distinct from FALSE
if inconsistent_assumptions:
  flag inconsistency; do not present arbitrary conclusions as reliable.

16. PROOF AND COUNTEREXAMPLE
prove_universal: derive Q(x) from arbitrary x and P(x), respecting domain.
disprove_universal: produce witness x where P(x) is true and Q(x) false.
proof_object: premises, rules, intermediate_steps, conclusion, verifier
counterexample_object: assignment, domain, antecedent_value, consequent_value

17. VALIDATION
V01: antecedent and consequent have proposition type
V02: connective and semantic regime declared
V03: variable scope and quantifiers resolved
V04: domain restrictions satisfied
V05: classical transformations restricted to classical semantics
V06: proof steps use admissible inference rules
V07: counterexample satisfies P AND NOT Q
V08: unknown/undecidable not relabelled false
V09: probabilistic conditional not confused with logical implication
V10: provenance and version recorded

18. CONFIDENCE
confidence.kind: epistemic_metadata_not_truth_value
confidence.inputs: proof_verification, source_reliability, semantic_disambiguation
confidence.rule: formal verified proof supports high confidence in derivation relative to assumptions
confidence.caveat: numeric confidence cannot substitute for a proof.

19. FLOW_HASH
FLOW_HASH:
  algorithm: SHA-256
  payload: canonical_AST | semantic_regime | domain | assumptions | ontology_version
  encoding: UTF-8
  note: compute hash on serialised canonical payload; do not fabricate hash values.

20. UPDATE_MODEL
on_change: antecedent | consequent | assumptions | domain | semantics | proof
  invalidate: cached_truth | proof_dependencies | semantic_equivalence | FLOW_HASH
  reprocess: parse -> validate -> infer -> publish
  preserve: previous_version + provenance + timestamp

21. AI_CONSUMPTION
expose: entity_id, canonical_formula, readable_formula, domain, semantics
expose: assumptions, proof_status, evidence, counterexample, confidence
reasoning_guardrails:
  - distinguish implication from causation
  - reject converse and inverse fallacies
  - preserve domain and quantifier scope
  - distinguish material, modal, constructive and probabilistic conditionals
  - report UNKNOWN where no justified conclusion is available

22. TEST CASES
T01: true -> false = false [material]
T02: false -> false = true [material]
T03: (P->Q) and P entails Q [valid]
T04: (P->Q) and Q entails P [invalid]
T05: contrapositive equivalence [valid in classical logic]
T06: forall x in R: x>2 -> x>1 [valid]
T07: forall x in R: x^2=4 -> x=2 [counterexample -2]
T08: conditional probability requires positive conditioning-event probability

23. PROVENANCE AND AUTHORSHIP
source_url: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/conditional-statement-ontology.html
source_verification: not independently verified
formal_basis: standard mathematical logic and formal semantics
co_authors: Mark Higgins; Sky (Recursive AI)
publisher: Kireth Research
website: https://kirethresearch.org

END FLOW ALGEBRA