Symbol Entity Graph Ontology

FLOW ALGEBRA
Symbol Entity Graph Ontology
Kireth Research Semantic Library
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/ai-semantic-library-mathematical-entities/symbol-entity-graph-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | 2026-10-15

1. PURPOSE
Model mathematical symbols as typed, context-dependent entities in a graph. Distinguish glyph identity, semantic meaning, binding scope, expression occurrence and provenance. Support reproducible parsing, resolution, validation, equivalence and AI retrieval.

2. ENTITY TYPES
SymbolEntity := {id, glyph, canonical_form, notation_system, kind, namespace, context_id, provenance_id}
SymbolOccurrence := {id, symbol_id, expression_id, span, scope_id, role}
MeaningEntity := {id, concept, domain, definition, type_signature}
ExpressionEntity := {id, syntax_tree, domain, assumptions}
ScopeEntity := {id, parent_scope, bound_identifiers}
NotationEntity := {id, convention, locale, rendering}
SourceEntity := {id, source_uri, version, attribution, timestamp}
ConfidenceRecord := {id, subject_id, score, evidence, method, calibration}

3. RELATION TYPES
DENOTES(SymbolEntity, MeaningEntity, Context)
OCCURS_IN(SymbolOccurrence, ExpressionEntity)
INSTANCE_OF(SymbolEntity, SymbolKind)
BOUND_IN(SymbolOccurrence, ScopeEntity)
REFERS_TO(SymbolOccurrence, SymbolEntity)
HAS_TYPE(SymbolEntity, MathematicalType)
OPERATES_ON(SymbolEntity, OperandType)
ALIAS_OF(SymbolEntity, SymbolEntity, Context)
EQUIVALENT_TO(MeaningEntity, MeaningEntity, Assumptions)
DEPENDS_ON(MeaningEntity, Assumption)
DERIVED_FROM(Entity, SourceEntity)
CONFLICTS_WITH(Interpretation, Interpretation, Context)

4. CORE FLOW
flow SymbolEntityGraph(input, context, sources):
  tokens := TOKENISE(input)
  occurrences := EXTRACT_SYMBOL_OCCURRENCES(tokens)
  scopes := RESOLVE_SCOPES(occurrences, context)
  candidates := GENERATE_MEANING_CANDIDATES(occurrences, context)
  typed := TYPE_CHECK(candidates, context.assumptions)
  resolved := DISAMBIGUATE(typed, scopes, context)
  graph := BUILD_TYPED_GRAPH(resolved, occurrences, sources)
  validation := VALIDATE_GRAPH(graph)
  confidence := ASSESS_CONFIDENCE(graph, validation)
  return PUBLISH(graph, validation, confidence, provenance=sources)

5. IDENTITY AND CONTEXT RULES
R1: Identical glyphs do not imply identical mathematical meanings.
R2: Symbol identity must include notation namespace and semantic context.
R3: A bound variable occurrence resolves to its nearest valid binding scope.
R4: Free variables remain unresolved until a declaration or explicit assumption exists.
R5: An overloaded operator must be resolved against operand types and context.
R6: Rendering variants may share a semantic identity only when justified by notation rules.
R7: Renaming a bound variable consistently preserves alpha-equivalence; renaming a free variable does not automatically preserve meaning.
R8: Equality of printed forms does not establish equality of typed expressions.

6. SYMBOL CLASSIFICATION
kinds := {variable, constant, parameter, operator, relation, function,
          quantifier, delimiter, index, tensor_symbol, unit_symbol,
          set_symbol, logical_connective, placeholder}
CLASSIFY(glyph, syntax_position, declarations, domain) -> candidate_kinds
REQUIRE kind-compatible type_signature for every resolved interpretation.

7. GRAPH CONSTRUCTION
NODE(SymbolEntity) -> stable identifier plus semantic metadata
NODE(SymbolOccurrence) -> unique expression position and scope
EDGE(REFERS_TO) -> occurrence-to-symbol identity
EDGE(DENOTES) -> context-qualified symbol-to-meaning link
EDGE(DERIVED_FROM) -> source traceability
MERGE nodes only if identity criteria and namespace rules pass.
Preserve distinct nodes for unresolved homographs.

8. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE(a, b, assumptions):
  require TYPE_COMPATIBLE(a, b)
  require CONTEXT_COMPATIBLE(a, b)
  result := PROVE_EQUIVALENCE(a, b, assumptions)
  return {status: proved | disproved | unknown, proof: result.evidence}
Never infer semantic equivalence from string similarity alone.

9. VALIDATION
VALIDATE_GRAPH(g):
  check UNIQUE_IDENTIFIERS(g)
  check VALID_RELATION_SIGNATURES(g)
  check SCOPE_CONSISTENCY(g)
  check TYPE_CONSISTENCY(g)
  check NO_UNSUPPORTED_EQUIVALENCE_ASSERTIONS(g)
  check PROVENANCE_LINKS(g)
  check ASSUMPTION_DEPENDENCIES(g)
  return {valid, errors, warnings, unresolved}
A graph with unresolved meanings may be partially valid but not fully resolved.

10. CONFIDENCE
CONFIDENCE(entity, evidence):
  score := CALIBRATED_ESTIMATE(evidence)
  return {score: score, evidence: evidence, method: calibration_method}
Confidence is not proof. A formally verified relation records proof status separately.
Do not assign fabricated numerical confidence where evidence is insufficient.

11. PROVENANCE
PROVENANCE(node) := {source_uri, extraction_method, author,
                     retrieved_at, source_version, assumptions}
Each derived relationship should retain a derivation chain to its input entities.

12. FLOW HASH
FLOW_HASH(graph):
  canonical := CANONICAL_SERIALISE(graph, include_types=true,
                                   include_context=true, include_assumptions=true)
  return SHA256(canonical)
Canonicalisation must fix ordering and encoding; exclude volatile retrieval metadata
from the semantic digest or store it in a separate provenance digest.

13. UPDATE MODEL
UPDATE_MODEL(existing_graph, changes):
  changed := DETECT_CHANGED_SYMBOLS_AND_CONTEXTS(changes)
  affected := TRACE_DEPENDENTS(existing_graph, changed)
  recomputed := RE_RESOLVE_AND_VALIDATE(affected)
  return VERSION_GRAPH(APPLY(existing_graph, recomputed), preserve_history=true)
Never silently overwrite historical interpretations.

14. AI CONSUMPTION
AI_CONSUMPTION(query, graph):
  matches := RETRIEVE_TYPED_SYMBOLS(query, graph)
  filtered := FILTER_BY_CONTEXT_SCOPE_AND_ASSUMPTIONS(matches)
  ranked := RANK_BY_RELEVANCE_AND_EVIDENCE(filtered)
  return {entities: ranked, definitions, relations, proof_status,
          unresolved_ambiguities, provenance, confidence}
AI systems must distinguish established definitions, derived claims and hypotheses.

15. EXAMPLE
Expression: f(x) = x^2
Entities: f:function, x:variable, 2:integer constant, ^:exponentiation operator
Relations: OCCURS_IN(x, expression), HAS_TYPE(2, integer),
           OPERATES_ON(^, numeric operands), DENOTES(f, squaring function, context)
Validation: x is bound by function argument declaration; operator types compatible.
Alternative context: f could denote a different function; context must govern resolution.

16. OUTPUT CONTRACT
output := {ontology: 'Symbol Entity Graph Ontology', version, graph,
           typed_entities, scoped_occurrences, semantic_relations,
           assumptions, validation, confidence, provenance,
           flow_hash, update_history, ai_consumption}

END FLOW ALGEBRA