Algebra Domain Ontology

FLOW ALGEBRA
TITLE: Algebra Domain Ontology
DOMAIN: Domain Ontologies / Mathematical Domains / Algebra
SOURCE: https://kirethresearch.org/booksai-core/ontologies/domain-ontologies/mathematical-domains/algebra-domain-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "AlgebraDomainOntology" v1.0 {
  ontology:
    id: "algebra-domain-ontology"
    parent: "mathematical-domains"
    purpose: "Represent algebraic structures, operations, equations, mappings and proof-backed relationships with explicit assumptions."

  types:
    AlgebraicStructure: {id: string, kind: enum[semigroup, monoid, group, ring, field, module, vector_space, algebra, other], carrier: string, operations: string[], axioms: string[]}
    Element: {id: string, structure_id: string, representation: string}
    Operation: {id: string, arity: integer, domain: string[], codomain: string, symbol: string?}
    Expression: {id: string, syntax: string, free_variables: string[], type: string}
    Equation: {id: string, lhs: -Expression, rhs: -Expression, assumptions: string[]}
    Mapping: {id: string, domain: string, codomain: string, kind: enum[function, homomorphism, isomorphism, endomorphism, automorphism, other]}
    Proof: {id: string, premises: string[], conclusion: string, steps: string[], provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    member_of(element: Element, structure: AlgebraicStructure)
    operates_on(operation: Operation, structure: AlgebraicStructure)
    satisfies_axiom(structure: AlgebraicStructure, axiom: string)
    equal_under(a: -Expression, b: -Expression, assumptions: string[])
    maps_to(mapping: Mapping, source: Element, target: Element)
    homomorphic_to(source: AlgebraicStructure, target: AlgebraicStructure, mapping: Mapping)
    isomorphic_to(source: AlgebraicStructure, target: AlgebraicStructure, mapping: Mapping)
    derived_from(conclusion: string, proof: Proof)

  constraints:
    - "Every operation must declare arity, domain and codomain."
    - "Do not assume commutativity, associativity, identity or inverses without applicable axioms."
    - "Check closure and type compatibility before evaluating operations."
    - "Equality transformations must preserve stated assumptions and solution domains."
    - "Division requires a nonzero divisor and a structure supporting the relevant inverse."
    - "A homomorphism must preserve specified operations; an isomorphism additionally requires bijectivity."
    - "Confidence values must lie within [0,1]; formal proof validity is distinct from empirical confidence."

  inference:
    rule equality_symmetry:
      if equal_under(a,b,ctx)
      then equal_under(b,a,ctx)
      confidence: "logical consequence under the same assumptions"
    rule equality_transitivity:
      if equal_under(a,b,ctx) and equal_under(b,c,ctx)
      then equal_under(a,c,ctx)
      confidence: "requires compatible types and assumptions"
    rule isomorphism_inverse:
      if isomorphic_to(a,b,f) and verified_bijection(f) and verified_operation_preservation(f)
      then isomorphic_to(b,a,inverse(f))
      confidence: "proof-backed"
    rule homomorphism_composition:
      if homomorphic_to(a,b,f) and homomorphic_to(b,c,g) and compatible(g,f)
      then homomorphic_to(a,c,compose(g,f))
      confidence: "proof-backed"

  SEMANTIC_EQUIVALENCE:
    - "Normalise algebraic notation only when types, assumptions and bound variables agree."
    - "Distinguish syntactic equality, algebraic equivalence, isomorphism and identity."
    - "Preserve the distinction between structures with similar names but different axioms."

  CONFIDENCE:
    range: [0,1]
    factors: [proof_verification, assumption_completeness, source_reliability, symbolic_computation_validation]
    policy: "Keep theorem validity, conjectural status and evidence-based confidence separate; do not invent proof certainty."

  VALIDATION:
    - "Check structure axioms, operation closure, typing and mapping domains."
    - "Verify each proof step and guard against division by zero or lost solutions."
    - "Detect contradictory assumptions and unsupported equivalence claims."
    - "Record unresolved propositions as conjectures rather than theorems."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, structures, typed assertions, rules and provenance"
    note: "Compute at execution; no precomputed hash is asserted."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, normalise, type_check, validate_axioms, verify_proofs, reconcile, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed algebraic knowledge graph with proof and assumption annotations"
    outputs: [structure_definitions, operation_signatures, equation_relations, mapping_relations, verified_inferences, provenance_records]
    safeguards: [preserve_assumptions, no_unproved_theorems, type_safe_transformations, explicit_uncertainty]
}

END FLOW ALGEBRA