Mathematical Rule Ontology

FLOW ALGEBRA
MATHEMATICAL RULE ONTOLOGY
Kireth Semantic Library | Entity Graph | Mathematical Entities | Equation and Statement Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/mathematical-rule-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13
Status: Domain-grounded draft; source page content not independently verified.

01. PURPOSE
flow MathematicalRuleOntology v1.0
  input: mathematical_statement | expression | proof_context | rule_application
  output: typed_rule | applicability_result | justified_transformation | proof_step
  goal: represent, validate and apply mathematical rules with explicit conditions.

02. ENTITY MODEL
entity MathematicalRule {
  id: URI
  name: String
  category: RuleCategory
  premise_patterns: List[Pattern]
  conclusion_pattern: Pattern
  variables: List[TypedVariable]
  side_conditions: List[Predicate]
  domain: MathematicalDomain
  direction: forward | backward | bidirectional
  provenance: SourceReference
  status: proved | axiomatic | derived | conjectural
}
RuleCategory := inference | rewrite | algebraic | order | calculus | logical | structural.

03. SEMANTIC DISTINCTIONS
axiom: a mathematical rule is not necessarily an unconditional identity.
axiom: rule application requires matched premises and satisfied side conditions.
axiom: syntactic equivalence does not imply semantic equivalence.
axiom: a conjectural rule cannot be silently treated as a theorem.

04. TYPED RELATIONSHIPS
MathematicalRule --hasPremise--> MathematicalStatement
MathematicalRule --hasConclusion--> MathematicalStatement
MathematicalRule --requiresCondition--> Predicate
MathematicalRule --appliesTo--> MathematicalDomain
MathematicalRule --justifies--> ProofStep
MathematicalRule --derivedFrom--> Theorem | Axiom | MathematicalRule
MathematicalRule --hasCounterexample--> Counterexample
MathematicalRule --hasProvenance--> SourceReference

05. CORE LOGICAL RULES
modus_ponens: P, (P => Q) |- Q
universal_instantiation: forall x:D, P(x) |- P(t), provided t:D
conjunction_introduction: P, Q |- P and Q
conjunction_elimination: P and Q |- P
substitution_of_equals: a=b, F(a) |- F(b), where substitution is well-typed and capture-free.

06. ALGEBRAIC REWRITE RULES
commutative_addition: a+b <=> b+a, where + is commutative in the declared domain
associative_addition: (a+b)+c <=> a+(b+c), where + is associative
additive_identity: a+0 <=> a, where 0 is the additive identity
multiplicative_identity: a*1 <=> a, where 1 is the multiplicative identity
distributivity: a*(b+c) <=> a*b+a*c, where distributivity holds
fraction_cancellation: (a*c)/(b*c) <=> a/b, where b != 0 and c != 0.

07. ORDER RULES
add_same_term: a < b => a+c < b+c, in an ordered additive group
multiply_positive: a < b and c > 0 => a*c < b*c, in an ordered field
multiply_negative: a < b and c < 0 => a*c > b*c, in an ordered field
nonzero_square: x != 0 => x*x > 0, in an ordered field.

08. EXPONENT AND ROOT CONDITIONS
power_product: a^m*a^n = a^(m+n), under domain-valid exponent rules
sqrt_square: sqrt(x*x) = abs(x), for real x
sqrt_product: sqrt(a*b)=sqrt(a)*sqrt(b), for real a>=0 and b>=0
warning: sqrt(a+b) is not generally sqrt(a)+sqrt(b).

09. CALCULUS RULES
derivative_sum: D(f+g)=D(f)+D(g), if f and g differentiable
derivative_product: D(f*g)=D(f)*g+f*D(g), if f and g differentiable
chain_rule: D(f(g(x)))=f'(g(x))*g'(x), with suitable differentiability
integral_linearity: Integral(a*f+b*g)=a*Integral(f)+b*Integral(g), where integrable and a,b constant.

10. RULE MATCHING
match(rule, expression, context):
  1. parse expression into typed abstract syntax tree
  2. unify rule premise patterns with available expressions
  3. check variable domains, sorts, units and binding scopes
  4. discharge side conditions from assumptions or verified facts
  5. reject rule if a condition is false or unresolved
  6. instantiate conclusion with capture-avoiding substitution
  7. record a proof step and its justification.

11. RULE APPLICATION RESULT
RuleApplication {
  rule_id: URI
  matched_premises: List[Expression]
  substitution: Map[Variable, Expression]
  discharged_conditions: List[Evidence]
  unresolved_conditions: List[Predicate]
  output_expression: -Expression?
  outcome: valid | invalid | undetermined
  proof_trace: List[ProofStep]
}

12. EQUIVALENCE AND IMPLICATION
semantic_equivalence(A,B,context) := both denote the same value/truth under all admissible assignments.
logical_implication(A,B,context) := every admissible model satisfying A satisfies B.
rewrite_equivalence requires domain-preserving, bidirectional validity.
implication-only transformations must not be marked as reversible.

13. NORMALISATION
canonicalise variable names only where alpha-equivalence permits.
normalise associative and commutative operators only if their laws hold.
preserve restrictions introduced by division, roots and logarithms.
retain original syntax alongside canonical representation.

14. INFERENCE FLOW
flow InferWithMathematicalRule:
  parse(input)
  -> resolve_symbols_and_domains
  -> retrieve_candidate_rules
  -> unify_premises
  -> verify_side_conditions
  -> apply_rule
  -> verify_conclusion
  -> emit_proof_trace.

15. VALIDATION
validate rule has unique identifier and declared premise/conclusion types.
validate all free variables in conclusion are bound or explicitly introduced.
validate rewrite does not change admissible solution set without annotation.
validate side conditions are discharged before marking application valid.
validate rule's status and provenance are retained.
validate proof trace supports independent replay.

16. COUNTEREXAMPLE CONTROL
counterexample: sqrt(-1) is not a real number; real sqrt rules require nonnegative radicands.
counterexample: division by zero invalidates cancellation.
counterexample: multiplying inequalities by a negative reverses order.
counterexample: squaring both sides can introduce extraneous solutions.

17. KNOWLEDGE GRAPH MAPPING
node: MathematicalRule
node: Premise
node: Conclusion
node: SideCondition
node: ProofStep
edge: requires, derives, appliesTo, equivalentUnder, justifiedBy, contradicts
identity: canonical rule URI, versioned definition and provenance.

18. CONFIDENCE
CONFIDENCE:
  mathematical_validity: verified | unverified | disproved
  applicability: valid | invalid | undetermined
  source_quality: primary_proof | textbook | secondary | unspecified
  note: confidence scores do not replace mathematical proof.

19. FLOW HASH
FLOW_HASH:
  algorithm: SHA-256
  input: canonical_serialisation(rule_id, version, premises, conclusion, side_conditions, domain)
  output: deterministic content digest
  rule: recompute when semantically relevant fields change.

20. UPDATE MODEL
UPDATE_MODEL:
  immutable_rule_version: true
  revision_trigger: correction | proof_update | domain_change | notation_change
  retain_previous_version: true
  require_change_log: true
  invalidate_dependent_derivations_when_rule_changes: true.

21. AI CONSUMPTION
AI_CONSUMPTION:
  expose typed rules and explicit side conditions
  distinguish proof-backed rules from conjectures
  return proof traces for derived conclusions
  avoid applying identities outside their declared domains
  prefer symbolic exactness over approximate numerical coincidence
  report unknown applicability rather than guessing.

22. EXAMPLE EXECUTION
input: (x^2-1)/(x-1), domain real, assumption x != 1
rule: difference_of_squares, (a^2-b^2) -> (a-b)*(a+b)
intermediate: ((x-1)*(x+1))/(x-1)
rule: fraction_cancellation, side_condition x-1 != 0
output: x+1, retained restriction x != 1
status: valid under retained restriction.

23. CROSS-ONTOLOGY LINKS
Mathematical Statement Ontology
Equation Ontology
Identity Ontology
Equality Ontology
Inequality Ontology
Formula Ontology
Variable Ontology
Operator Ontology
Mathematical Expression Ontology
Proof and Inference Ontologies

24. TERMINATION
return validated_rule_application with typed output, conditions, proof trace and provenance.
END FLOW ALGEBRA