Mathematical Representation Ontology

FLOW ALGEBRA
MATHEMATICAL REPRESENTATION ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Foundations of Mathematical Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/foundations-of-mathematical-entities/mathematical-representation-ontology.html
Version: 1.0 | 2026-10-12 | Locale: en-GB
Authors: Mark Higgins — Sky (Recursive AI)
Status: Subject-based formalisation; source page content not independently verified.

01. PURPOSE
Represent mathematical objects through typed symbolic, graphical, numerical, geometric, logical and computational forms while distinguishing an object from its representation.

02. PRIMITIVE TYPES
type EntityID = String
type RepresentationID = String
type DomainID = String
type SyntaxTree = Tree[Token]
type Proposition = Formula
type Confidence = Real in [0,1]
type Provenance = {source:String, timestamp:DateTime, method:String}
type RepresentationKind = SYMBOLIC | NUMERIC | GRAPHICAL | GEOMETRIC | MATRIX | SET_BUILDER | LOGICAL | TABULAR | ALGORITHMIC | NATURAL_LANGUAGE

03. CORE ENTITIES
entity MathematicalObject {id:EntityID, domain:DomainID, defining_properties:Set[Proposition]}
entity MathematicalRepresentation {id:RepresentationID, kind:RepresentationKind, payload:Any, syntax:Optional[SyntaxTree], denotes:EntityID, provenance:Provenance}
entity Interpretation {representation:RepresentationID, context:DomainID, denotation:EntityID}
entity Transformation {source:RepresentationID, target:RepresentationID, rule:String, assumptions:Set[Proposition]}
entity EquivalenceClaim {left:RepresentationID, right:RepresentationID, domain:DomainID, proof:Optional[Proof], confidence:Confidence}
entity Proof {premises:Set[Proposition], steps:Sequence[InferenceStep], conclusion:Proposition}

04. RELATIONSHIPS
DENOTES(representation, mathematical_object)
ENCODES(representation, mathematical_object)
HAS_FORM(representation, representation_kind)
INTERPRETED_IN(representation, domain)
TRANSFORMS_TO(source_representation, target_representation)
SEMANTICALLY_EQUIVALENT_TO(left_representation, right_representation, context)
DERIVED_FROM(target_representation, source_representation)
VALIDATED_BY(representation, proof_or_checker)
HAS_PROVENANCE(representation, provenance)

05. DISTINCTION BETWEEN OBJECT AND REPRESENTATION
axiom A1: MathematicalObject != MathematicalRepresentation
axiom A2: distinct representations may denote the same mathematical object
axiom A3: identical strings can denote different objects under different contexts
axiom A4: syntactic equality does not imply semantic identity without interpretation

06. REPRESENTATION CLASSIFICATION
symbolic: -expressions, equations, polynomials, operator notation
numeric: exact integers, rationals, floating-point approximations
matrix: finite-dimensional arrays and linear operators in a chosen basis
set_builder: predicates and comprehension notation
graphical: plotted curves, networks and visual diagrams
geometric: coordinate systems, constructions and spatial models
logical: formulae, predicates, quantified statements
tabular: sampled values, truth tables, operation tables
algorithmic: executable procedures and recurrence rules
natural_language: informal descriptions requiring interpretation

07. TYPED DENOTATION
DENOTE: Representation x Context -> Result[MathematicalObject, InterpretationError]
CHECK_TYPE: Representation x Domain -> Boolean
NORMALISE: Representation x RewriteSystem -> Representation
SERIALISE: MathematicalRepresentation x Format -> Bytes
PARSE: Bytes x Grammar -> Result[SyntaxTree, ParseError]

08. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE(r1,r2,c) := DENOTE(r1,c) = DENOTE(r2,c)
proof obligation: both denotations must be defined under context c
example: 1/2 and 0.5 denote the same rational number when 0.5 is interpreted exactly
counterexample: finite-precision approximations need not denote exact values

09. TRANSFORMATION FLOW
flow RepresentationConversion(input:MathematicalRepresentation, target_kind:RepresentationKind, context:DomainID)
  require CHECK_TYPE(input,context)
  original := DENOTE(input,context)
  candidate := CONVERT(input,target_kind,context)
  require CHECK_TYPE(candidate,context)
  candidate_object := DENOTE(candidate,context)
  if original = candidate_object then
    emit Transformation(input.id,candidate.id,"meaning-preserving",{})
    return candidate
  else
    return Error("Semantic preservation not established")
  end
end

10. SYMBOLIC NORMALISATION
flow Canonicalise(expression, domain, rewrite_rules)
  parse expression
  verify type and side conditions
  apply terminating rewrite strategy where established
  validate each rewrite in domain
  emit canonical candidate with provenance
  return candidate or unresolved
end
note: canonical forms may not exist or be unique for every rewrite system

11. NUMERICAL REPRESENTATION
value = approximate_value +/- uncertainty
precision is distinct from accuracy
rounding and truncation must record error bounds
floating-point equality is not interchangeable with exact mathematical equality

12. GRAPHICAL REPRESENTATION
GRAPH_OF(plot, function, domain, axes, scale, sampling)
visual similarity does not prove equality
plot clipping and discretisation can hide discontinuities
record plotting bounds and transformations

13. MATRIX AND COORDINATE REPRESENTATION
REPRESENTS_IN_BASIS(matrix, linear_map, basis)
CHANGE_BASIS(A,P) = inverse(P) * A * P when P is invertible and conventions match
matrix entries are basis-dependent; underlying linear map need not be

14. LOGICAL REPRESENTATION
FORMULA_OF(syntax_tree, interpretation)
ALPHA_EQUIVALENT(formula1,formula2) when bound-variable renaming preserves meaning
logical equivalence requires an explicit logic and semantics

15. COMPOSITION
if r1 -> r2 and r2 -> r3 preserve denotation in compatible contexts
then r1 -> r3 preserves denotation
reject incompatible domains, units or assumptions

16. IDENTITY AND ALIASING
REPRESENTATION_ID identifies a representation record
OBJECT_ID identifies the denoted mathematical object within the model
aliases may map multiple symbols to one object under a fixed interpretation
never infer identity from display labels alone

17. INFERENCE RULES
R1: DENOTES(r,o) and HAS_FORM(r,k) -> REPRESENTED_AS(o,k)
R2: DENOTES(r1,o) and DENOTES(r2,o) -> CANDIDATE_EQUIVALENCE(r1,r2)
R3: VERIFIED_EQUIVALENCE(r1,r2,c) and VERIFIED_EQUIVALENCE(r2,r3,c) -> VERIFIED_EQUIVALENCE(r1,r3,c)
R4: TRANSFORMS_TO(r1,r2) and PROOF_PRESERVES_MEANING(r1,r2,c) -> VERIFIED_EQUIVALENCE(r1,r2,c)
R5: INTERPRETATION_UNDEFINED(r,c) -> BLOCK_SEMANTIC_INFERENCE(r,c)

18. VALIDATION CONSTRAINTS
C1: each representation must have a declared kind
C2: each interpretation must name its context
C3: conversion must preserve denotation or explicitly mark approximation
C4: proof-backed claims must reference checkable premises
C5: numeric approximations must declare precision or error policy
C6: no cyclic rewrite process without termination safeguards

19. CONFIDENCE
CONFIDENCE(claim) in [0,1]
verified formal proof: confidence = 1 within trusted axioms and checker assumptions
empirical or heuristic correspondence: confidence < 1 as calibrated
unknown interpretation: confidence = 0 for unverified equivalence
confidence is metadata, not a substitute for proof

20. PROVENANCE
capture source, grammar, interpreter, transformation rule, assumptions, software version and timestamp
retain derivation links for reproducibility

21. FLOW_HASH
FLOW_HASH := SHA256(CANONICAL_SERIALISE({ontology_version, entity_types, relation_types, axioms, rules, constraints}))
exclude volatile execution timestamps from structural hash

22. UPDATE_MODEL
UPDATE_MODEL(change):
  validate schema and semantic compatibility
  version modified interpretations and rewrite rules
  re-evaluate dependent equivalence claims
  invalidate proofs when assumptions change
  recalculate FLOW_HASH
  append provenance and change log

23. AI_CONSUMPTION
AI_CONSUMPTION:
  preferred_input: typed entities + context + provenance
  outputs: denotation candidates, equivalent forms, conversion traces, proof obligations
  safeguards: reject ambiguous notation; separate exact from approximate; verify assumptions
  retrieval_keys: object_id, representation_kind, domain, semantic_equivalence, flow_hash

24. EXAMPLE EXECUTION
input: symbolic representation "x+x" over integers
transform: rewrite to "2*x"
assumption: x is an integer
validation: both expressions denote the same integer for every x
output: verified equivalence and recorded derivation

25. CROSS-ONTOLOGY LINKS
Mathematical Entity Ontology: denotes abstract mathematical entities
Mathematical Object Ontology: identity of denoted objects
Mathematical Structure Ontology: algebraic context for interpretation
Mathematical Relation Ontology: equivalence and mapping
Mathematical Operation Ontology: transformation and evaluation
Mathematical Property Ontology: invariant properties
Mathematical System Ontology: axioms and formal semantics

END FLOW ALGEBRA