Abstract Object Ontology

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

01. PURPOSE
flow AbstractObjectOntology v1.0:
  intent: represent non-spatiotemporal abstract objects, their identities, types, properties, relations, interpretations and proofs.
  scope: mathematics, logic, formal semantics, knowledge representation.
  distinction: abstract-object representation is not evidence of independent metaphysical existence.

02. TYPE SYSTEM
type AbstractObject = {id: URI, kind: AbstractKind, theory: TheoryRef, definition: Formula?, provenance: SourceRef?}
type AbstractKind = Number | Set | Function | Relation | Proposition | Structure | Type | Symbol | Algorithm | GeometricObject | Other
type TheoryRef = {id: URI, axioms: Set[Formula], logic: LogicSystem}
type Formula = {syntax: AST, free_variables: Set[Variable], well_formed: Bool}
type Interpretation = {theory: TheoryRef, domain: Domain, valuation: Mapping}
type Claim = {subject: AbstractObject, predicate: Relation, object: Term, context: TheoryRef}
type Proof = {premises: Set[Formula], conclusion: Formula, steps: Sequence[InferenceStep], calculus: ProofSystem}
type Evidence = {source: SourceRef, validation: ValidationStatus, confidence: Real[0,1]}

03. IDENTITY AND EXISTENCE
rule IdentityReflexivity: well_typed(x,T) => equals_T(x,x)
rule IdentitySymmetry: equals_T(x,y) => equals_T(y,x)
rule IdentityTransitivity: equals_T(x,y) and equals_T(y,z) => equals_T(x,z)
constraint: equality is interpreted relative to theory, type and chosen semantics.
constraint: object identifiers do not by themselves establish mathematical equality.
constraint: existence claims must state quantifier domain and axiomatic context.

04. CLASSIFICATION
relation instance_of(AbstractObject, AbstractKind)
relation defined_in(AbstractObject, TheoryRef)
relation member_of(AbstractObject, Set)
relation subset_of(Set, Set)
relation domain_of(Function, Set)
relation codomain_of(Function, Set)
relation satisfies(AbstractObject, Formula)
relation represents(Symbol, AbstractObject)
relation isomorphic_to(Structure, Structure)
relation equivalent_under(AbstractObject, AbstractObject, EquivalenceRelation)

05. CONSTRUCTION
operation Declare(id, kind, theory, definition?) -> AbstractObject
  pre: valid_identifier(id) and theory.exists
  post: registered(id) and type_checked(definition, theory)
operation Construct(constructor, args, theory) -> AbstractObject | Error
  pre: constructor_signature_matches(args)
  post: result_well_typed or Error
operation Interpret(object, interpretation) -> SemanticValue | Undefined
  pre: interpretation.model_of(object.theory)

06. RELATIONAL ALGEBRA
compose(R,S)(x,z) := exists y: R(x,y) and S(y,z)
inverse(R)(y,x) := R(x,y)
restrict(R,A,B) := {(x,y) in R | x in A and y in B}
identity(T) := {(x,x) | x in T}
constraint: composition requires compatible domains and codomains.

07. MATHEMATICAL OPERATIONS
operation Apply(f,x) -> y
  pre: f.kind=Function and x in domain(f)
  post: y=f(x) and y in codomain(f)
operation Substitute(phi,var,term) -> Formula
  pre: term.type compatible_with var.type
  post: capture_avoiding_substitution(phi,var,term)
operation Normalize(expr, rewrite_system) -> NormalForm | Unknown
  pre: rewrite_system.rules_are_typed
  note: termination and confluence are not assumed.

08. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE(a,b,context) -> Bool | Unknown:
  if proven(context |- a = b): return true
  if proven(context |- not(a = b)): return false
  return Unknown
rule Isomorphism: isomorphic_to(A,B) => same_structure_up_to_isomorphism(A,B)
constraint: isomorphism does not imply literal object identity.
constraint: syntactic equality, definitional equality and semantic equivalence are distinct.

09. INFERENCE ENGINE
INFER(premises, rule, theory) -> DerivedClaim | Rejected:
  require all(premise.well_formed for premise in premises)
  require rule.sound_for(theory.logic)
  require premises.satisfy(rule.antecedent)
  conclusion := rule.apply(premises)
  return DerivedClaim(conclusion, proof_trace, theory)
constraint: no inference without explicit rule, context and trace.

10. PROOF VERIFICATION
VERIFY(proof, theory) -> Valid | Invalid | Unknown:
  if not typecheck(proof): return Invalid
  if any(not licensed(step, proof.calculus, theory) for step in proof.steps): return Invalid
  if final_statement(proof) != proof.conclusion: return Invalid
  if missing_external_axiom_or_oracle_validation(proof): return Unknown
  return Valid

11. CONFIDENCE
CONFIDENCE(claim) -> Real[0,1] | Unknown:
  if formally_verified(claim.proof, claim.theory): return 1.0
  if claim.has_empirical_or_heuristic_support: return calibrated_estimate(claim.evidence)
  return Unknown
constraint: confidence 1.0 means verified relative to the stated formal system, not absolute truth in every model.
constraint: Unknown is not equivalent to zero confidence.

12. DEPENDENCIES AND PROVENANCE
relation derived_from(Claim, Claim)
relation uses_axiom(Proof, Formula)
relation uses_definition(AbstractObject, Formula)
relation authored_by(SourceRef, Agent)
relation version_of(AbstractObject, AbstractObject)
require: preserve theory version, proof trace, definitions and source identifiers.

13. GRAPH REPRESENTATION
node: AbstractObject {id,kind,theory,definition_hash}
node: Theory {id,axiom_set_hash,logic}
node: Claim {id,formula,proof_status}
edge: DEFINED_IN | INSTANCE_OF | MEMBER_OF | RELATES_TO | DERIVED_FROM | EQUIVALENT_UNDER | REPRESENTS
constraint: all edges carry domain/range constraints and provenance where applicable.

14. CONSISTENCY CHECKS
VALIDATE(graph) -> ValidationReport:
  check unique_stable_identifiers
  check type_correct_edges
  check well_formed_formulas
  check no_unlicensed_cross_theory_substitution
  check proof_references_resolve
  check equality_contexts_explicit
  report contradictions without silently discarding them

15. RECURSIVE REASONING
RECURSE(goal, theory, depth_limit, visited) -> Proof | Unknown:
  if goal in visited: return Unknown
  if depth_limit <= 0: return Unknown
  if axiom_or_verified_theorem(goal,theory): return Proof
  for candidate_rule in admissible_rules(goal,theory):
    attempt proof of each premise with depth_limit-1
    if all premises verified: return compose_proof(candidate_rule)
  return Unknown
constraint: bounded recursion does not guarantee completeness.

16. UPDATE MODEL
UPDATE_MODEL(old_graph, changes, theory_version) -> UpdatedGraph | Conflict:
  validate changes and dependency impact
  preserve historical versions
  invalidate proof caches dependent on changed axioms or definitions
  rebuild affected semantic indices
  return updated graph only if validation succeeds

17. FLOW HASH
FLOW_HASH(flow) -> SHA256:
  canonical := canonical_serialisation(flow, excluding_volatile_metadata=true)
  return SHA256(UTF8(canonical))
constraint: hash equality indicates identical canonical bytes, not semantic equivalence.

18. AI CONSUMPTION
AI_CONSUMPTION:
  input: typed graph + axioms + claims + proof traces + provenance
  outputs: grounded retrieval, type-safe reasoning, explainable deductions
  require: context-bound semantics, explicit uncertainty, provenance retention
  forbid: treating unverified conjectures as proven theorems

19. TEST CASES
case identity: equality reflexive within a fixed theory -> pass
case function: applying outside domain -> type/domain error
case sets: A subset B and B subset C -> infer A subset C
case equivalence: isomorphic structures -> do not infer identical IDs
case proof: unlicensed inference step -> invalid
case unknown: undecidable or unresolved statement -> Unknown, not false
case update: axiom revision -> invalidate dependent proof caches
case hashing: identical canonical serialisation -> identical digest

20. INTEGRATION
parent: Foundations of Mathematical Entities
siblings: Mathematical Entity Ontology, Mathematical Object Ontology, Mathematical Structure Ontology
cross_links: Set Theory, Formal Logic, Model Theory, Category Theory, Knowledge Graphs, Semantic Metadata

21. LIMITATIONS
This flow is an executable-style conceptual specification, not a complete implementation or certified proof assistant.
Concrete syntax, logic calculus, axiom schemas, serialization and inference runtime must be supplied for production execution.

END FLOW ALGEBRA