Mathematical Symbol Ontology

FLOW ALGEBRA
MATHEMATICAL SYMBOL ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Symbolic Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/symbolic-entities/mathematical-symbol-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | 2026-10-13
Status: Domain-derived formalisation; source page content not independently verified.

01. PURPOSE
flow MathematicalSymbolOntology v1.0:
  domain: mathematical_knowledge_representation
  objective: identify, type, parse, resolve, validate and reason about mathematical symbols
  principle: a glyph is not necessarily a unique mathematical concept

02. CORE ENTITY TYPES
  MathematicalSymbol <: SymbolicEntity
  SymbolOccurrence <: MathematicalSymbolUse
  SymbolType := {variable, constant, operator, relation, delimiter, quantifier, function_name, set_symbol, logical_connective, index, unit_symbol, notation_marker}
  SymbolOccurrence := (glyph, codepoint_sequence, position, expression_id, context_id)
  SymbolMeaning := (concept_id, type, arity?, domain?, codomain?, definition?, scope?)
  SymbolBinding := (occurrence_id, meaning_id, environment_id)
  Expression := (syntax_tree, context_id, type?)
  Namespace := (identifier, governing_conventions)

03. ENTITY RELATIONSHIPS
  HAS_GLYPH(SymbolOccurrence, Glyph)
  OCCURS_IN(SymbolOccurrence, Expression)
  HAS_ROLE(SymbolOccurrence, SymbolType)
  RESOLVES_TO(SymbolOccurrence, SymbolMeaning)
  DECLARED_IN(SymbolMeaning, Namespace)
  BINDS(QuantifierOrBinder, VariableOccurrence)
  OPERATES_ON(OperatorOccurrence, OperandExpression)
  DENOTES(SymbolMeaning, MathematicalEntity)
  EQUIVALENT_NOTATION(SymbolMeaning, SymbolMeaning, Context)
  DEPENDS_ON(SymbolMeaning, DefinitionOrAxiom)

04. REPRESENTATION AND CONTEXT
  lexical_form: UTF-8 sequence; preserve original source
  normalised_form: optional, recorded separately
  rendering: plain_text | Unicode | LaTeX | MathML
  scope: local | expression | theorem | document | ontology
  notation_context: branch, field, convention, discipline, author
  warning: visually similar glyphs may be distinct identifiers
  warning: identical glyphs may denote distinct objects or operations

05. SYMBOL CLASSES AND EXAMPLES
  variable: x, y, n
  constant: pi, e, i (meaning requires context)
  arithmetic_operator: +, -, *, /
  relational_operator: =, <, <=, >, >=
  logical_connective: and, or, not, implies
  quantifier: forall, exists
  set_notation: element_of, subset_of, union, intersection
  delimiter: parentheses, brackets, braces, absolute_value_bars
  function_notation: f(x), sin(x), log(x)
  index_notation: x_i, a_n
  examples are role illustrations, not globally fixed meanings

06. TYPED SYMBOL SCHEMA
  symbol.id: string (required)
  symbol.glyph: string (required)
  symbol.category: SymbolType (required)
  symbol.context_id: string (required)
  symbol.meaning_id: string? (optional until disambiguated)
  symbol.arity: integer >= 0 | variable | null
  symbol.fixity: prefix | infix | postfix | binder | atomic | null
  symbol.associativity: left | right | none | context_dependent
  symbol.precedence: integer? (notation-specific)
  symbol.operand_types: Type[]?
  symbol.result_type: Type?
  symbol.provenance: source_ref
  symbol.confidence: number in [0,1]

07. PARSING FLOW
  INPUT(source, notation_profile)
  -> TOKENISE(preserve_offsets=true)
  -> IDENTIFY_GLYPHS
  -> RESOLVE_LEXICAL_AMBIGUITY
  -> PARSE(precedence, fixity, delimiters)
  -> BUILD_ABSTRACT_SYNTAX_TREE
  -> RESOLVE_BINDINGS(namespace, scope)
  -> TYPE_CHECK
  -> MAP_SEMANTICS
  -> VALIDATE
  -> EMIT(typed_graph, provenance)
  on_failure: emit structured ambiguity or error; never invent a meaning

08. TYPE AND ARITY RULES
  IF role(s)=binary_operator THEN operand_count(s)=2
  IF role(s)=unary_operator THEN operand_count(s)=1
  IF role(s)=relation THEN result_type(s)=Boolean (under classical semantics)
  IF function f: A -> B AND x in A THEN f(x) in B
  IF binding unresolved THEN semantic_status=ambiguous
  IF symbol used outside declared scope THEN semantic_status=unbound
  exceptions: overloaded and variadic operators require explicit signatures

09. SCOPE AND VARIABLE BINDING
  FREE_VARIABLE(x,E) iff x occurs in E without an enclosing binding for x
  BOUND_VARIABLE(x,E) iff an enclosing binder governs its occurrence
  ALPHA_EQUIVALENCE: renaming bound variables without capture preserves meaning
  CAPTURE_AVOIDING_SUBSTITUTION(E,x,t) required for valid rewriting
  same glyph across scopes does not imply identical binding

10. SEMANTIC EQUIVALENCE
  GLYPH_EQUAL(a,b) does not imply MEANING_EQUAL(a,b)
  MEANING_EQUAL(a,b,context) requires compatible referents and signatures
  NOTATION_EQUIVALENT(a,b,context) requires a documented mapping
  ALPHA_EQUIVALENT(E1,E2) permits bound-variable renaming
  avoid asserting equivalence for similar appearance alone

11. MATHEMATICAL OPERATIONS
  RESOLVE(symbol,context) -> meaning | ambiguity
  APPLY(operator,operands,environment) -> expression | type_error
  SUBSTITUTE(expression,variable,term) -> capture_avoiding_expression
  NORMALISE(expression,rule_set) -> expression
  COMPARE_SYMBOLS(a,b,context) -> equal | distinct | unknown
  SERIALISE(expression,format) -> representation
  ROUND_TRIP(parse(serialize(E))) must preserve semantics where supported

12. KNOWLEDGE GRAPH MAPPING
  node: SymbolOccurrence {id,glyph,position,context_id}
  node: SymbolMeaning {id,role,signature,namespace}
  node: MathematicalEntity {id,type}
  edge: OCCURS_IN | RESOLVES_TO | DENOTES | BINDS | OPERATES_ON
  edge: EQUIVALENT_NOTATION | DEPENDS_ON | HAS_PROVENANCE
  constraints: meaning must not be inferred from glyph alone

13. INFERENCE RULES
  R1: DECLARED_AS(s,m,c) and OCCURS_IN(s,c) => CANDIDATE_MEANING(s,m)
  R2: CANDIDATE_MEANING(s,m) and TYPE_COMPATIBLE(s,m) and UNIQUE(m) => RESOLVES_TO(s,m)
  R3: RESOLVES_TO(s,m) and DENOTES(m,e) => REFERS_TO(s,e)
  R4: BINDER(q,x,E) => BOUND_IN(x,E,q) for governed occurrences only
  R5: NOTATION_EQUIVALENT(a,b,c) and VALID_CONTEXT(c) => SUBSTITUTE_NOTATION(a,b,c)
  R6: MULTIPLE_COMPATIBLE_MEANINGS(s) => REQUIRE_DISAMBIGUATION(s)
  rule applications retain evidence and scope

14. VALIDATION
  V1: unique symbol occurrence identifiers
  V2: source offsets correspond to original expression
  V3: valid Unicode/notation encoding
  V4: balanced delimiters under grammar
  V5: declared scope for bound identifiers
  V6: operand arity and type compatibility
  V7: no conflicting unqualified semantic bindings
  V8: semantic rewrites preserve intended mathematical meaning
  V9: every assertion records provenance and context
  V10: unresolved notation marked unknown, not silently resolved

15. CONFIDENCE
  confidence(symbol_resolution) := calibrated score in [0,1]
  exact_declaration: strong evidence
  context_consistent_inference: supporting evidence
  glyph_only_guess: insufficient evidence
  ambiguity: retain multiple candidates and request context
  mathematical_truth is not determined by confidence score

16. SEMANTIC DIFFERENCE
  difference(a,b) := compare(glyph, role, signature, referent, scope, context)
  categories: lexical | syntactic | type | semantic | scope | representational
  identical typography may have semantic difference
  differing typography may express equivalent semantics

17. FLOW HASH
  FLOW_HASH := SHA256(canonical_serialisation(ontology_version, schema, rules, context_policy))
  canonicalisation: stable ordering, explicit encoding, versioned schema
  exclude transient timestamps unless deliberately included
  distinguish source_content_hash from flow_definition_hash

18. UPDATE MODEL
  UPDATE_MODEL := {version, change_type, previous_hash, new_hash, effective_date, provenance}
  change_type: addition | correction | deprecation | breaking_semantic_change
  retain historical meanings for reproducible interpretation
  invalidate dependent inferences after incompatible meaning changes

19. AI CONSUMPTION
  input: source_expression, notation_profile, namespace, domain_context
  output: typed_ast, entity_graph, bindings, interpretations, validation_report
  required: provenance, uncertainty, ambiguity, version, flow_hash
  do_not: collapse overloaded symbols without contextual evidence
  do_not: treat glyph similarity as mathematical identity
  do_not: equate symbolic notation with numerical evaluation

20. EXAMPLE
  expression: 'x + 2 = 5'
  declarations: x: Real; +: Real x Real -> Real; =: Real x Real -> Boolean
  parse: Equals(Add(x,2),5)
  constraints: x in Real
  derived_solution: x = 3
  inference_basis: field axioms of real arithmetic
  caveat: '+' could have another interpretation under another context

21. QUALITY AND LIMITATIONS
  The ontology formalises symbol representation and interpretation.
  It does not prove arbitrary mathematical claims merely by parsing them.
  Formal proofs require a selected logic, axioms and trusted inference rules.
  Source page text was not independently inspected for this edition.

END FLOW ALGEBRA