Recursive Mathematical Knowledge Graph Ontology

FLOW ALGEBRA
Recursive Mathematical Knowledge Graph Ontology
Version: 1.0
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/ai-semantic-library-mathematical-entities/recursive-mathematical-knowledge-graph-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Licence: Open Research Licence — unrestricted research, educational and practical reuse.

PURPOSE
Represent mathematical knowledge as a typed, recursively traversable graph with explicit inference, validation, provenance and controlled updates. This is a declarative specification; implementations must supply a parser, graph store and proof checker.

ENTITY TYPES
  MathematicalEntity := Symbol | Expression | Equation | Definition | Axiom | Theorem | Lemma | Proof | Rule | Model | Domain | Graph | GraphVersion
  Node := {id: URI, type: MathematicalEntity, label: string, payload: typed value, context: URI?, version: integer}
  Edge := {id: URI, source: URI, predicate: Predicate, target: URI, context: URI?, evidence: URI?}
  Predicate := DEFINES | USES | DEPENDS_ON | PROVES | DERIVES | EQUIVALENT_TO | GENERALISES | SPECIALISES | IN_DOMAIN | HAS_ASSUMPTION | HAS_PROVENANCE | REVISES
  ProofStatus := UNCHECKED | VERIFIED | REFUTED | INDETERMINATE
  Confidence := real in [0,1]

GRAPH STATE
  G := (V, E, T, P, C, R)
  V := finite set of typed nodes
  E := finite set of typed edges
  T := type and predicate constraints
  P := provenance ledger
  C := confidence annotations
  R := immutable graph revision identifier

INVARIANTS
  I1: every node id is unique within a graph revision
  I2: every edge endpoint resolves to an existing node
  I3: edge predicates satisfy declared domain and range restrictions
  I4: every inference records premises, rule, context and provenance
  I5: VERIFIED requires a successful independent proof check; confidence alone cannot establish truth
  I6: revisions are append-only and previous revisions remain addressable
  I7: cycles in graph references are permitted; recursive evaluation must detect revisits
  I8: equivalent expressions may be merged only under compatible domains, assumptions and semantics

TYPED OPERATIONS
  ADD_NODE(G, n:Node) -> G' | Error
  ADD_EDGE(G, e:Edge) -> G' | Error
  RESOLVE(G, id:URI) -> Node? 
  NEIGHBOURS(G, id:URI, predicate:Predicate?) -> Set[Node]
  DEPENDENCY_CLOSURE(G, id:URI) -> Set[Node]
  INFER(G, rule:Rule, premises:Set[Node], context:URI) -> Candidate
  VERIFY(candidate:Candidate, checker:ProofChecker) -> ProofStatus
  COMMIT(G, candidate:Candidate, evidence:URI) -> G' | Error
  COMPARE(G1, G2) -> ChangeSet

RECURSIVE GRAPH TRAVERSAL
  closure(G, root, visited):
    if root in visited: return empty set
    visited' := visited union {root}
    next := targets of outgoing DEPENDS_ON edges from root
    return {root} union UNION(closure(G, x, visited') for x in next)
  Require bounded resources or explicit depth limits for large or untrusted graphs.

RECURSIVE INFERENCE
  seed := explicitly supplied axioms, definitions and checked results
  step(K) := K union {c | exists applicable rule r with premises in K,
                      all assumptions satisfied, and c verified by checker}
  K_0 := seed
  K_(n+1) := step(K_n)
  stop when K_(n+1) = K_n or resource limit reached
  A fixed point over a finite, monotone rule universe terminates; unrestricted term generation may not.
  Nonmonotone retractions require versioned truth-maintenance rather than this fixed-point rule.

SEMANTIC EQUIVALENCE
  EQUIVALENT_TO(a,b,context) only if a and b denote the same mathematical object
  under stated assumptions, type rules and interpretation.
  Example: x^2 - 1 and (x - 1)(x + 1) are equivalent over commutative rings.
  Do not infer equivalence merely from similar names, embeddings or notation.

PROVENANCE
  record := {source_uri, source_revision, author_or_agent, timestamp,
             inference_rule, premise_ids, checker_id, checker_version,
             assumptions, result_status}
  Provenance is required for derived nodes and edges.

CONFIDENCE
  CONFIDENCE(candidate) := calibrated evidence score in [0,1]
  Keep confidence distinct from ProofStatus.
  Aggregation is implementation-defined and must document dependence between sources.
  Low-confidence candidates remain unverified until independently checked.

FLOW_HASH
  canonical := deterministic serialisation of typed graph revision, including
               nodes, edges, assumptions, proof statuses and provenance references
  FLOW_HASH := SHA-256(canonical)
  Hash identifies a serialised revision; it is not a mathematical proof.

UPDATE_MODEL
  1. Receive proposed node, edge or rule change.
  2. Validate schema, references, domain/range and assumptions.
  3. Calculate affected dependency closure.
  4. Re-check impacted proofs and invalidate stale derived claims.
  5. Create immutable revision and provenance record.
  6. Recompute canonical hash and publish revision metadata.
  7. Permit rollback by selecting a prior immutable revision.

AI_CONSUMPTION
  Input: natural-language or symbolic mathematical query with context.
  Resolve symbols and definitions to typed graph nodes.
  Retrieve relevant dependency and proof subgraphs.
  Execute only approved inference rules with explicit assumptions.
  Return result, supporting proof path, provenance, proof status, confidence,
  graph revision and unresolved ambiguities.
  Never present a conjecture or model-generated candidate as a verified theorem.

EXAMPLE
  Nodes: Axiom_A, Rule_R, Proposition_P, Proof_P
  Edges: Proposition_P DEPENDS_ON Axiom_A
         Proof_P USES Rule_R
         Proof_P PROVES Proposition_P
  If the proof checker verifies Proof_P under the recorded assumptions,
  set ProofStatus(Proposition_P) = VERIFIED in a new graph revision.

VALIDATION TESTS
  T1: reject edge to missing target.
  T2: reject incompatible predicate domain/range.
  T3: terminate recursive traversal on cyclic references.
  T4: preserve assumptions during equivalence checks.
  T5: invalidate affected proof statuses after dependency revision.
  T6: stable canonical input yields stable FLOW_HASH.
  T7: rejected proof cannot be marked VERIFIED by high confidence.
  T8: query output includes provenance and graph revision.

END FLOW ALGEBRA