Mathematical Definition Ontology

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

01. PURPOSE
flow "MathematicalDefinitionOntology" v1.0
  objective: represent mathematical definitions as typed, scoped, verifiable semantic objects
  distinguishes: [definition, axiom, theorem, conjecture, notation, example]
  outputs: [canonical_definition, typed_relations, validation_result, provenance]

02. CORE ENTITIES
entity MathematicalDefinition:
  id: URI
  definiendum: MathematicalConcept | Symbol | Predicate | Structure
  definiens: WellFormedExpression | LogicalFormula | ConstructiveSpecification
  context: TheoryContext
  assumptions: Set[Proposition]
  parameters: OrderedList[TypedVariable]
  scope: Scope
  definition_kind: DefinitionKind
  dependencies: Set[ConceptReference]
  provenance: Provenance
  version: VersionIdentifier

entity TheoryContext:
  signature: TypedSignature
  logic: LogicSystem
  axioms: Set[Formula]
  interpretation: Optional[Interpretation]

entity Provenance:
  source_uri: URI
  author: Optional[String]
  date: Optional[Date]
  verification_status: Enum[draft, reviewed, formally_verified]

03. DEFINITION KINDS
DefinitionKind := explicit | implicit | inductive | recursive | constructive | axiomatic | stipulative | contextual | operational
explicit: defines a new symbol using previously meaningful expressions
implicit: constrains interpretation via conditions; uniqueness may require proof
inductive: specifies base cases and constructors or closure rules
recursive: specifies base values and well-founded recursive steps
constructive: supplies a method or construction witnessing an object
axiomatic: characterises structures through axioms; not necessarily categorical
contextual: meaning depends on surrounding theory or binding context
operational: fixes meaning by a specified procedure where appropriate

04. TYPED RELATIONSHIPS
relation DEFINES(MathematicalDefinition, MathematicalConcept)
relation HAS_DEFINIENS(MathematicalDefinition, Formula)
relation HAS_PARAMETER(MathematicalDefinition, TypedVariable)
relation ASSUMES(MathematicalDefinition, Proposition)
relation IN_THEORY(MathematicalDefinition, TheoryContext)
relation DEPENDS_ON(MathematicalDefinition, ConceptReference)
relation REFINES(MathematicalDefinition, MathematicalDefinition)
relation EQUIVALENT_UNDER(MathematicalDefinition, MathematicalDefinition, TheoryContext)
relation CONFLICTS_WITH(MathematicalDefinition, MathematicalDefinition, TheoryContext)
relation HAS_PROOF_OBLIGATION(MathematicalDefinition, Proposition)
relation SUPERSEDES(VersionIdentifier, VersionIdentifier)

05. FORMAL SEMANTICS
For explicit predicate definition P(x) := phi(x):
  required: P is fresh in the relevant signature
  required: free_variables(phi) subset_of {x} union allowed_context_parameters
  interpretation: forall x (P(x) iff phi(x))
  obligation: phi is well-formed and well-typed in context

For functional definition f(x) := t(x):
  required: t(x) has the declared codomain type
  required: t(x) is defined for every x in the declared domain
  interpretation: forall x in Domain, f(x) = t(x)

For implicit definition Phi(X):
  required: satisfiability of Phi in intended models
  uniqueness: prove separately if unique interpretation is claimed

06. CONSERVATIVE EXTENSION
rule ExplicitDefinitionConservative:
  if fresh(symbol) and well_typed(definiens) and total_where_required
  then introduction of symbol is a definitional extension
  note: conservativity requires appropriate logical and theoretical conditions

07. DEPENDENCY GRAPH
node: DefinitionID
edge: DefinitionID -> referenced DefinitionID
check: all referenced symbols resolvable in theory context
check: no unlicensed cyclic dependency
allow: recursive definitions only with documented well-foundedness or fixed-point semantics

08. SCOPE AND BINDING
rule AlphaRename:
  bound-variable renaming preserves meaning when capture is avoided
rule Substitute:
  substitute only with type compatibility and capture avoidance
rule NamespaceResolution:
  same spelling does not imply same concept across distinct namespaces

09. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE(d1,d2,C):
  requires: compatible signatures and aligned parameters
  requires: C entails forall x (definiens(d1,x) iff definiens(d2,x))
  returns: verified | disproved | unknown
  warning: textual similarity alone never proves equivalence

10. EXAMPLE DEFINITIONS
example EvenInteger:
  context: standard integers Z
  definiendum: Even(n)
  definiens: exists k in Z such that n = 2*k
  consequence: Even(4) = true

example PrimeNatural:
  context: natural numbers N
  definiendum: Prime(n)
  definiens: n > 1 and forall d in N, (d divides n implies (d = 1 or d = n))
  consequence: Prime(2) = true; Prime(1) = false

example Group:
  context: set G and binary operation star: G x G -> G
  definiens: associativity and identity existence and inverse existence
  note: closure is encoded by the operation's declared type

11. INFERENCE RULES
rule UnfoldDefinition:
  input: defined predicate P(t)
  condition: valid definition in current context
  output: defining predicate phi(t)

rule FoldDefinition:
  input: phi(t)
  condition: verified equivalence and valid scope
  output: P(t)

rule CheckDependency:
  input: new definition d
  output: unresolved references, cycles, theory mismatches

rule DefinitionConflict:
  input: d1,d2 sharing symbol and scope
  output: conflict only if incompatible interpretations are established

12. VALIDATION
validate schema: all mandatory fields present
validate syntax: parseable formula and symbol declarations
validate typing: operands, functions, quantifiers and result types match
validate scope: free variables declared or supplied by context
validate freshness: explicit defined symbols do not silently shadow existing symbols
validate consistency: flag contradictions relative to declared theory
validate recursion: termination or suitable fixed-point semantics documented
validate proof: all asserted equivalences carry evidence or unknown status
validate provenance: source and revision available

13. CONFIDENCE
CONFIDENCE:
  syntax_confidence: derived from parser checks
  semantic_confidence: derived from proof or model checks
  provenance_confidence: derived from traceable evidence
  rule: never infer formal truth from a confidence score
  unknown: permitted when verification is incomplete

14. CANONICALISATION
canonicalise:
  normalise Unicode and supported mathematical notation without changing meaning
  resolve qualified identifiers and binder scopes
  alpha-normalise bound variables where valid
  sort unordered metadata fields only
  preserve original expression and theory context
  do_not: equate syntactically similar but semantically distinct definitions

15. FLOW_HASH
FLOW_HASH:
  algorithm: SHA-256
  payload: canonical(serialised_definition + theory_id + assumptions + version)
  purpose: content identity, change detection and deduplication
  warning: equal hash identifies equal canonical payloads, not independent proof of mathematical correctness

16. UPDATE_MODEL
UPDATE_MODEL:
  event: definition_created | definition_revised | context_changed | proof_updated | deprecated
  on_change: revalidate dependencies and downstream inferences
  preserve: immutable revision history and source attribution
  invalidate: cached conclusions dependent on superseded definitions when warranted

17. KNOWLEDGE GRAPH TRIPLES
<Definition:EvenInteger> rdf:type <MathematicalDefinition>
<Definition:EvenInteger> DEFINES <Concept:EvenInteger>
<Definition:EvenInteger> IN_THEORY <Theory:IntegerArithmetic>
<Definition:EvenInteger> HAS_DEFINIENS "exists k in Z: n=2*k"
<Concept:EvenInteger> SUBCLASS_OF <Concept:Integer>

18. AI_CONSUMPTION
AI_CONSUMPTION:
  parse: typed fields, symbols and theory references
  retrieve: by concept, namespace, theorem dependencies and definition kind
  reason: unfold/fold only under validated conditions
  answer: include assumptions, relevant definitions and proof status
  abstain: when ambiguous, conflicting or unverified
  preserve: mathematical notation, provenance and semantic distinctions

19. EXECUTION PIPELINE
pipeline:
  1: ingest definition text and provenance
  2: parse into typed syntax tree
  3: resolve symbols, scope and theory context
  4: classify definition kind
  5: construct dependency graph
  6: validate syntax, types and proof obligations
  7: canonicalise and calculate FLOW_HASH
  8: emit knowledge graph relationships
  9: publish versioned AI-consumable record
  10: monitor revisions and propagate invalidations

20. INVARIANTS
invariant: definition has an identifiable definiendum
invariant: definition's meaning is interpreted relative to context
invariant: asserted equivalence requires contextual justification
invariant: symbol binding is capture-safe
invariant: recursive definitions require legitimate semantics
invariant: source provenance remains attached across revisions

21. OUTPUT CONTRACT
output:
  ontology: MathematicalDefinitionOntology
  schema_version: "1.0"
  definition_record: MathematicalDefinition
  validation: pass | fail | unknown
  proof_obligations: Set[Proposition]
  semantic_links: Set[TypedRelation]
  flow_hash: SHA256Digest
  revision: VersionIdentifier
  consumption_status: ready | review_required | rejected

END FLOW ALGEBRA