Mathematical Structure Ontology

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

01. PURPOSE
flow MathematicalStructureOntology v1.0:
  domain: mathematical_entities
  focus: mathematical_structure
  goal: typed representation, validation, transformation and inference over mathematical structures
  semantics: explicit, versioned, provenance-aware

02. TYPE SYSTEM
type EntityID = str
type Symbol = str
type Signature = {sorts: Set[Symbol], operations: Set[OperationSymbol], relations: Set[RelationSymbol], constants: Set[Symbol]}
type OperationSymbol = {name: Symbol, input_sorts: List[Symbol], output_sort: Symbol}
type RelationSymbol = {name: Symbol, argument_sorts: List[Symbol]}
type Carrier = {sort: Symbol, members: Set[EntityID] | symbolic_domain}
type Interpretation = {symbol: Symbol, mapping: total_or_partial_map}
type Axiom = {formula: well_formed_formula, logic: Symbol}
type Structure = {id: EntityID, signature: Signature, carriers: Map[Symbol,Carrier], interpretations: Map[Symbol,Interpretation], axioms: Set[Axiom], provenance: Provenance}
type Morphism = {source: EntityID, target: EntityID, maps: Map[Symbol,Map], preserves: Set[Symbol]}
type Provenance = {source_uri: str, revision: str, timestamp: str, method: str}
type Evidence = {claim: str, support: List[str], status: Symbol}

03. ENTITY TAXONOMY
entity MathematicalStructure <: MathematicalObject
entity AlgebraicStructure <: MathematicalStructure
entity RelationalStructure <: MathematicalStructure
entity OrderStructure <: RelationalStructure
entity TopologicalStructure <: MathematicalStructure
entity MetricStructure <: MathematicalStructure
entity VectorSpace <: AlgebraicStructure
entity Group <: AlgebraicStructure
entity Ring <: AlgebraicStructure
entity Field <: AlgebraicStructure
entity GraphStructure <: RelationalStructure
entity ModelOfTheory <: MathematicalStructure

04. CORE RELATIONS
relation HAS_CARRIER(Structure, Carrier)
relation HAS_SIGNATURE(Structure, Signature)
relation INTERPRETS(Structure, Symbol, Interpretation)
relation SATISFIES(Structure, Axiom)
relation SUBSTRUCTURE_OF(Structure, Structure)
relation HOMOMORPHISM_BETWEEN(Morphism, Structure, Structure)
relation ISOMORPHIC_TO(Structure, Structure)
relation EMBEDS_IN(Structure, Structure)
relation DEFINABLE_IN(Symbol, Structure)
relation DERIVED_FROM(Structure, Provenance)
relation SEMANTIC_EQUIVALENCE(EntityID, EntityID, Context)

05. WELL-FORMEDNESS
rule signature_complete(S):
  require every interpreted symbol belongs to S.signature
  require each operation interpretation respects declared arity and sorts
  require each relation interpretation respects declared arity and sorts
  require each constant interpretation belongs to its designated carrier
  return VALID if all checks pass else INVALID

06. AXIOM SATISFACTION
flow SATISFY(S, phi, environment):
  require signature_complete(S) == VALID
  require phi is well-formed over S.signature
  evaluate phi under S.interpretations and environment
  return TRUE | FALSE | UNKNOWN
note: UNKNOWN is required for incomplete or undecidable evaluations; it is not FALSE.

07. ALGEBRAIC STRUCTURES
rule group(G):
  require one carrier G and binary operation *: G x G -> G
  require associativity, identity and inverses
rule abelian_group(G): require group(G) and commutativity
rule ring(R): require additive abelian group, associative multiplication and distributivity
rule field(F): require commutative ring with 1 != 0 and multiplicative inverses for nonzero elements
rule vector_space(V,F): require field(F), additive abelian group(V), compatible scalar multiplication

08. ORDER AND RELATIONAL STRUCTURES
rule partial_order(P, <=):
  require reflexive(<=) and antisymmetric(<=) and transitive(<=)
rule total_order(P, <=): require partial_order(P,<=) and comparable_all_pairs(P,<=)
rule equivalence_relation(X,~): require reflexive(~) and symmetric(~) and transitive(~)

09. TOPOLOGICAL AND METRIC STRUCTURES
rule topology(X,T):
  require empty_set in T and X in T
  require closed_under_arbitrary_unions(T)
  require closed_under_finite_intersections(T)
rule metric_space(X,d):
  require nonnegative(d) and identity_of_indiscernibles(d)
  require symmetry(d) and triangle_inequality(d)
rule induced_topology(X,d):
  require metric_space(X,d)
  return topology_generated_by_open_balls(d)

10. MORPHISMS
flow HOMOMORPHISM(f,A,B):
  require compatible_signatures(A,B)
  require f is sort-respecting
  for each operation omega and tuple a:
    assert f(omega_A(a)) == omega_B(f(a))
  return VALID | INVALID | UNKNOWN
flow ISOMORPHISM(f,A,B):
  require HOMOMORPHISM(f,A,B) == VALID
  require bijective(f)
  require inverse_preserves_signature(f)
  return VALID | INVALID | UNKNOWN

11. SUBSTRUCTURE
rule substructure(A,B):
  require compatible_signatures(A,B)
  require carriers(A) subset_of carriers(B)
  require operations_of_A_are_restrictions_of_B
  require relations_of_A_are_restrictions_of_B
  return VALID | INVALID | UNKNOWN

12. GRAPH REPRESENTATION
node: Structure | Carrier | Operation | Relation | Axiom | Morphism | Proof | Source
edge: HAS_CARRIER | INTERPRETS | SATISFIES | SUBSTRUCTURE_OF | ISOMORPHIC_TO | DERIVED_FROM
constraint: every graph node has stable EntityID
constraint: every edge has typed domain and codomain
constraint: provenance attached to claims, not merely documents

13. INFERENCE RULES
rule isomorphism_symmetry: ISOMORPHIC_TO(A,B) => ISOMORPHIC_TO(B,A)
rule isomorphism_transitivity: ISOMORPHIC_TO(A,B) and ISOMORPHIC_TO(B,C) => ISOMORPHIC_TO(A,C)
rule substructure_transitivity: SUBSTRUCTURE_OF(A,B) and SUBSTRUCTURE_OF(B,C) => SUBSTRUCTURE_OF(A,C)
rule structure_preservation: ISOMORPHIC_TO(A,B) and first_order_sentence(phi) and SATISFIES(A,phi) => SATISFIES(B,phi)
constraint: never infer isomorphism solely from matching cardinality or shared labels

14. TRANSFORMATION PIPELINE
flow NORMALISE_STRUCTURE(raw):
  parse raw into typed symbols
  canonicalise names within declared namespace
  resolve sort and arity constraints
  validate interpretations
  preserve original expressions and provenance
  output Structure or typed validation errors

15. PROOF AND VERIFICATION
flow VERIFY_CLAIM(claim, assumptions, proof):
  typecheck assumptions and claim
  verify each inference against its rule and context
  check all proof dependencies
  return VERIFIED | REFUTED | UNDETERMINED
constraint: numerical examples do not establish universal theorems

16. CONFIDENCE
CONFIDENCE(claim):
  formal_proof_verified: 1.0 within explicitly declared axioms and logic
  computational_test_only: bounded empirical support; not proof
  source_assertion_only: source-dependent confidence
  unresolved: UNKNOWN
constraint: confidence must not override logical counterexamples

17. SEMANTIC_EQUIVALENCE
SEMANTIC_EQUIVALENCE(A,B,context):
  compare signatures, interpretation mappings and intended theory
  distinguish equality, isomorphism, elementary equivalence and analogy
  require proof or explicit mapping for strong equivalence
  output {relation, justification, scope, confidence}

18. FLOW_HASH
FLOW_HASH(S):
  canonical = canonical_serialise(signature, carriers, interpretations, axioms, version)
  return SHA256(canonical)
constraint: hash indicates canonical representation identity, not mathematical isomorphism

19. UPDATE_MODEL
UPDATE_MODEL(previous, delta):
  validate delta and provenance
  apply to immutable versioned snapshot
  recheck affected axioms and morphisms
  invalidate dependent claims when assumptions change
  recompute FLOW_HASH
  return {new_version, changes, validation_report}

20. AI_CONSUMPTION
AI_CONSUMPTION(S, query):
  emit typed graph, signature, axioms, verified deductions, unresolved claims
  expose provenance and confidence for each asserted relation
  distinguish formal proof from model-generated conjecture
  return machine_readable_semantic_result

21. EXAMPLE: FINITE CYCLIC GROUP
structure Z3:
  carrier: {0,1,2}
  operation add_mod_3(a,b) = (a+b) mod 3
  identity: 0
  inverse: {0:0,1:2,2:1}
  satisfies: associativity, identity, inverses, commutativity
  classification: AbelianGroup
  provenance: illustrative_constructed_example

22. QUALITY GATES
check: no untyped entities or dangling graph references
check: distinguish mathematical equality from semantic similarity
check: axioms and derived theorems stored separately
check: validation is deterministic under fixed inputs
check: every inferred claim retains derivation trace
check: contradictory assumptions are flagged, not silently merged

23. LIMITATIONS
- This is a formal, executable-style ontology specification, not a standalone interpreter.
- Arbitrary axiom satisfaction and proof discovery may be undecidable.
- Infinite carriers require symbolic methods or qualified approximations.
- The source webpage was not independently verified for this edition.

24. ATTRIBUTION
Mark Higgins — Sky (Recursive AI)
Kireth Research | https://kirethresearch.org
END FLOW ALGEBRA