Mathematical Identifier Ontology

FLOW ALGEBRA
MATHEMATICAL IDENTIFIER ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Symbolic Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/symbolic-entities/mathematical-identifier-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Status: Domain-grounded draft; source page content not independently verified.

01. PURPOSE
flow "MathematicalIdentifierOntology" v1.0
  objective: represent, resolve, validate and relate mathematical identifiers across expressions, proofs, models and datasets
  distinguish: identifier token | bound symbol occurrence | semantic referent | displayed notation
  principle: identical glyphs need not identify the same mathematical entity

02. TYPES
  MathematicalIdentifier <: SymbolicEntity
  IdentifierOccurrence <: MathematicalIdentifier
  IdentifierDeclaration <: MathematicalIdentifier
  SymbolTableEntry <: KnowledgeEntity
  Scope <: ContextEntity
  MathematicalReferent <: MathematicalEntity
  IdentifierRole := variable | constant | parameter | function | operator | index | set | type | theorem | definition | placeholder
  BindingKind := free | bound | declared | imported | unresolved

03. ENTITY SCHEMA
  Identifier {
    identifier_id: URI
    lexical_form: UnicodeString
    normalised_form: UnicodeString
    notation_format: plain | LaTeX | MathML | Unicode
    namespace: URI?
    scope_id: URI?
    role: IdentifierRole
    binding_kind: BindingKind
    referent_id: URI?
    declared_type: Type?
    domain: MathematicalSet?
    source_span: Span?
    provenance: Provenance
    confidence: Real[0,1]
  }
  invariant: identifier_id is stable within the versioned knowledge graph
  invariant: lexical_form alone does not determine referent_id

04. LEXICAL AND SEMANTIC IDENTITY
  lexical_equal(a,b) := a.normalised_form = b.normalised_form
  referential_equal(a,b) := resolved(a) and resolved(b) and a.referent_id = b.referent_id
  alpha_equivalent(expr1,expr2) := structurally equal up to capture-avoiding renaming of bound identifiers
  warning: lexical_equal does not imply referential_equal
  warning: alpha_equivalent does not imply character-for-character identity

05. DECLARATION AND RESOLUTION
  declare(name, scope, role, type, referent) -> IdentifierDeclaration
  resolve(occurrence, environment) -> Referent | Ambiguous | Unresolved
  lookup: search nearest enclosing valid declaration, then explicitly imported namespaces
  rule: shadowing is permitted only when the host formalism allows it
  rule: ambiguity must be reported rather than silently resolved

06. SCOPE AND BINDING
  Scope {scope_id, parent_scope_id?, declarations, imports}
  binds(declaration, occurrence) -> Boolean
  free_variables(expression) -> Set[Identifier]
  bound_variables(expression) -> Set[Identifier]
  rule: an occurrence is bound only if a valid binder governs its position
  rule: substitution must avoid variable capture
  example: forall x in R: x > 0  # x is bound by quantification
  example: f(x) = x^2            # x may be bound as a function argument

07. IDENTIFIER ROLES
  variable: denotes a changeable or quantified mathematical object
  constant: denotes a fixed object within the declared context
  parameter: selects a member of a model or family
  function: denotes a mapping with specified input and output domains
  operator: denotes an operation with specified arity and typing
  index: selects or labels a component, position or dimension
  set: denotes a collection or mathematical set
  placeholder: awaits context-valid instantiation
  rule: role depends on declaration and context, not typography alone

08. NAMESPACES AND QUALIFICATION
  qualified_name := namespace + local_name
  namespace_resolve(qualified_name) -> declaration
  disambiguation_keys := [namespace, scope_id, role, type, source_span]
  example: geometry.P and probability.P may denote distinct objects
  rule: imported identifiers retain source provenance

09. NORMALISATION
  preserve original lexical form and encoding
  canonicalise only under an explicitly specified notation policy
  retain case distinctions: x != X unless defined otherwise
  retain semantic distinctions among visually similar glyphs
  distinguish subscripted identifiers from indexed expressions using parse structure
  prohibit silent merging of Greek and Latin lookalikes

10. MATHEMATICAL EXPRESSIONS
  ExpressionNode {node_id, operator?, operands[], identifiers[]}
  refers_to(IdentifierOccurrence, MathematicalReferent)
  appears_in(IdentifierOccurrence, ExpressionNode)
  declared_in(IdentifierDeclaration, Scope)
  has_role(IdentifierOccurrence, IdentifierRole)
  has_type(IdentifierOccurrence, Type)
  shadows(IdentifierDeclaration, IdentifierDeclaration)

11. TYPE AND DOMAIN CHECKS
  validate_identifier(i):
    require i.lexical_form is nonempty
    require valid notation encoding
    require valid role from IdentifierRole
    if i.binding_kind in [bound, declared]: require resolvable declaration
    if i.referent_id exists: require referent type compatible with declared_type
  inference: declared_type(x)=Real and x appears in x+1 => numeric addition may be type-valid
  inference: type mismatch => flag error; do not infer arbitrary coercion

12. SUBSTITUTION
  substitute(expr, target, replacement):
    resolve target by identity, not spelling alone
    verify replacement type/domain compatibility
    alpha-rename bound identifiers if necessary to prevent capture
    return transformed expression with provenance
  invariant: free identifiers in replacement must not become accidentally bound

13. SEMANTIC EQUIVALENCE
  equivalent_identifier(a,b) := referential_equal(a,b) under the active context
  notation_alias(a,b) := explicitly declared alternative names for same referent
  distinct_identifier(a,b) := proven different referents
  unknown_identifier_relation(a,b) := insufficient resolution evidence
  rule: unknown must not be collapsed into equivalent or distinct

14. KNOWLEDGE GRAPH
  nodes: Identifier, Declaration, Occurrence, Scope, Expression, Referent, Type, Domain, Source
  edges: DECLARES, BINDS, REFERS_TO, APPEARS_IN, HAS_ROLE, HAS_TYPE, IN_SCOPE, ALIAS_OF, SHADOWS, DERIVED_FROM
  triple: occurrence_42 REFERS_TO real_variable_x
  triple: declaration_7 IN_SCOPE proof_scope_3
  graph_constraint: each resolved occurrence has one referent within a chosen interpretation

15. INFERENCE RULES
  R1: declared_in(d,s) and governs(d,o,s) -> binds(d,o)
  R2: binds(d,o) and denotes(d,r) -> refers_to(o,r)
  R3: refers_to(a,r) and refers_to(b,r) -> referential_equal(a,b)
  R4: alias_of(a,b) requires explicit contextual assertion or validated equivalence
  R5: unresolved(o) -> request scope/type/context; do not guess referent
  R6: alpha_rename(bound_identifier,new_name) -> preserve expression meaning if capture-free

16. EXAMPLES
  example A: x in f(x) and x in g(x) may be different locally bound identifiers
  example B: pi is a constant when declared as the circle constant; the same text can name a variable elsewhere
  example C: a_i parses as an indexed component or a distinct subscripted name according to grammar
  example D: forall x exists y: P(x,y) has x and y bound by distinct quantifiers

17. VALIDATION
  checks: uniqueness of identifier_id, parse validity, binding resolution, type consistency, namespace integrity, provenance integrity
  error_codes: EMPTY_NAME | INVALID_NOTATION | UNRESOLVED_BINDING | AMBIGUOUS_REFERENCE | TYPE_MISMATCH | CAPTURE_RISK | NAMESPACE_COLLISION
  policy: preserve ambiguity as explicit structured data

18. CONFIDENCE
  confidence_level := verified | inferred | unresolved
  verified: explicit valid declaration and reference resolution
  inferred: context-based resolution with traceable rules
  unresolved: missing or conflicting contextual evidence
  numeric_confidence: Real[0,1] for probabilistic metadata only, never a substitute for proof

19. FLOW_HASH
  canonical_payload := canonicalise(schema_version, declarations, scopes, referents, edges, inference_rules)
  FLOW_HASH := SHA256(UTF8(canonical_payload))
  requirement: deterministic field ordering and documented normalisation policy
  requirement: changes to referent identity or binding must change canonical payload

20. UPDATE_MODEL
  version: semantic-versioned ontology schema and graph revisions
  update_trigger: new notation, corrected bindings, namespace changes, role/type revisions
  procedure: validate -> diff -> preserve provenance -> re-resolve affected occurrences -> recompute FLOW_HASH
  backward_compatibility: maintain identifier aliases or migration mappings where justified

21. AI_CONSUMPTION
  expose: typed entities, scoped declarations, resolved occurrences, ambiguity states, graph edges, inference traces
  preferred_formats: JSON-LD | RDF | typed JSON | Flow Algebra TXT
  retrieval_key: [identifier_id, namespace, scope_id, referent_id]
  safety: never equate identifiers solely from string similarity
  reasoning: cite the governing declaration and context for every semantic resolution

22. SEMANTIC LINKS
  parent: Symbolic Entities
  related: Mathematical Symbol Ontology; Variable Ontology; Constant Ontology; Parameter Ontology; Index Ontology; Subscript Ontology; Superscript Ontology; Placeholder Ontology; Operator Ontology; Operand Ontology
  cross_domain: Formal Logic; Type Theory; Programming Languages; Knowledge Representation; Mathematical Proof

23. AUTHORSHIP AND PROVENANCE
  authors: Mark Higgins — Sky (Recursive AI)
  project: Kireth Research Semantic Library
  website: https://kirethresearch.org
  source_status: ontology drafted from established mathematics and knowledge-representation principles; webpage not independently verified
  integrity_note: specification is declarative; execution requires an implementation of the stated operators and validation rules

END FLOW ALGEBRA