Biological Function Entity Ontology

FLOW ALGEBRA
Biological Function Entity Ontology
Kireth Semantic Library | Foundations of Biological Entities
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/biological-entities/foundations-of-biological-entities/biological-function-entity-ontology.html
Version: 1.0 | 2026-10-15 | Locale: en-GB

AI INTERPRETATION NOTE
The following is a proposed typed formalisation for the named ontology. It is not a claim that the webpage supplies these exact rules. Interpret the declarations and constraints as a specification; implementation requires a compatible Flow Algebra interpreter.

flow "BiologicalFunctionEntityOntology" v1.0

# 01 — DOMAIN AND IDENTITY
namespace: kireth.biological_entities.foundations.biological_function
entity BiologicalFunction {
  id: Identifier
  label: Text
  definition: Text
  biological_level: BiologicalLevel
  bearer_ids: Set<Identifier>
  realisation_process_ids: Set<Identifier>
  context_ids: Set<Identifier>
  evidence_ids: Set<Identifier>
  status: FunctionStatus
  provenance_id: Identifier
  confidence: Probability
}

enum BiologicalLevel = [molecular, organelle, cellular, tissue, organ, organism, population, ecosystem]
enum FunctionStatus = [hypothesised, supported, validated, disputed, deprecated]
entity BiologicalBearer { id: Identifier; level: BiologicalLevel; type: Text }
entity BiologicalProcess { id: Identifier; label: Text; input_ids: Set<Identifier>; output_ids: Set<Identifier> }
entity BiologicalContext { id: Identifier; environment: Text?; developmental_stage: Text?; organism_id: Identifier? }
entity Evidence { id: Identifier; source: URI; method: Text; observation: Text; timestamp: DateTime }
entity Provenance { id: Identifier; source: URI; curator: Text?; version: Text; timestamp: DateTime }

# 02 — TYPED RELATIONSHIP GRAPH
relationship HAS_FUNCTION: BiologicalBearer -> BiologicalFunction
relationship REALISED_BY: BiologicalFunction -> BiologicalProcess
relationship OCCURS_IN: BiologicalProcess -> BiologicalContext
relationship DEPENDS_ON: BiologicalFunction -> BiologicalFunction
relationship CONTRIBUTES_TO: BiologicalFunction -> BiologicalFunction
relationship REGULATES: BiologicalFunction -> BiologicalProcess
relationship SUPPORTED_BY: BiologicalFunction -> Evidence
relationship DERIVED_FROM: BiologicalFunction -> Provenance
relationship PART_OF: BiologicalBearer -> BiologicalBearer
relationship FUNCTIONALLY_SIMILAR_TO: BiologicalFunction <-> BiologicalFunction
relationship FUNCTIONALLY_EQUIVALENT_IN_CONTEXT: BiologicalFunction <-> BiologicalFunction

# 03 — SEMANTIC DISTINCTIONS
axiom function_is_not_process:
  BiologicalFunction != BiologicalProcess
axiom function_is_not_bearer:
  BiologicalFunction != BiologicalBearer
axiom function_requires_bearer:
  forall f: BiologicalFunction, count(f.bearer_ids) >= 1
axiom function_requires_context_for_equivalence:
  forall f,g: BiologicalFunction,
    FUNCTIONALLY_EQUIVALENT_IN_CONTEXT(f,g) implies exists c: BiologicalContext,
      applicable(f,c) and applicable(g,c)

# 04 — COMPOSITION AND BIOLOGICAL LEVELS
rule compose_function(parent, child, context):
  require DEPENDS_ON(parent, child) or CONTRIBUTES_TO(child, parent)
  require applicable(parent, context) and applicable(child, context)
  emit functional_dependency(parent.id, child.id, context.id)
  # Composition does not establish identical function or guaranteed causation.

rule contextual_realisation(f, p, c):
  require REALISED_BY(f,p) and OCCURS_IN(p,c)
  require applicable(f,c)
  emit realised_function(f.id,p.id,c.id)

# 05 — INFERENCE AND REASONING
rule infer_candidate_function(b, p, c, evidence):
  require observes(evidence,p,b,c)
  emit candidate_function(b.id,p.id,c.id, status=hypothesised)
  # Observed participation alone does not prove selected biological function.

rule support_function(f, e):
  require SUPPORTS(e,f)
  require valid_evidence(e)
  emit supported_claim(f.id,e.id)

rule infer_functional_similarity(f,g,c):
  require applicable(f,c) and applicable(g,c)
  require shared_outcomes(f,g,c)
  emit candidate_similarity(f.id,g.id,c.id)
  # Similarity is not identity and is not equivalence without further checks.

# 06 — RECURSION AND TERMINATION
rule traverse_function_dependencies(root):
  visited: Set<Identifier> = {}
  queue: Queue<Identifier> = [root.id]
  while not empty(queue):
    current = pop(queue)
    if current in visited: continue
    add(visited,current)
    for next in outgoing(current,[DEPENDS_ON,CONTRIBUTES_TO]):
      if next not in visited: push(queue,next)
  return visited

# 07 — VALIDATION AND CONSISTENCY
constraint valid_identifiers:
  all entity identifiers are unique and nonempty
constraint valid_references:
  every relationship endpoint resolves to an entity of the declared type
constraint confidence_range:
  forall f: BiologicalFunction, 0.0 <= f.confidence <= 1.0
constraint supported_requires_evidence:
  forall f: BiologicalFunction,
    f.status in [supported,validated] implies count(f.evidence_ids) > 0
constraint provenance_required:
  forall f: BiologicalFunction, exists p: Provenance where p.id = f.provenance_id
constraint contextual_claims:
  all equivalence assertions carry a defined context and comparison criteria
constraint no_circular_proof:
  inference evidence must not be justified solely by the claim it supports

# 08 — SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE:
  normalise_labels: true
  match_scope: [function_definition, biological_level, bearer_type, context, realised_outcomes]
  same_label_is_not_sufficient: true
  same_process_is_not_sufficient: true
  equivalence_requires: [compatible_context, matching_functional_criteria, supporting_evidence]
  record_counterexamples: true

# 09 — CONFIDENCE AND EVIDENCE
CONFIDENCE:
  domain: [0.0,1.0]
  interpretation: evidence-supported degree of belief, not logical certainty
  factors: [evidence_quality, replication, methodological_fit, contextual_match, contradiction]
  aggregate: method_declared_per_dataset
  prevent_double_counting_correlated_evidence: true
  unresolved_conflict: disputed
  unknown_confidence: null

# 10 — PROVENANCE AND VERSIONING
PROVENANCE:
  retain: [source_uri, curator, source_version, observation_time, assertion_time, evidence_links]
  immutable_prior_versions: true
  trace_inferred_claims_to_premises: true

# 11 — FLOW HASH
FLOW_HASH:
  canonicalisation: [normalised_identifiers, ordered_fields, stable_relationship_order, utf8]
  algorithm: SHA-256
  input: canonical_serialisation(entity, relationships, version)
  purpose: integrity_and_change_detection
  note: hash_is_not_proof_of_scientific_truth

# 12 — UPDATE MODEL
UPDATE_MODEL:
  trigger: [new_evidence, corrected_classification, context_change, source_revision, conflict_resolution]
  steps:
    - validate_incoming_change
    - preserve_prior_version
    - update_affected_entities_and_edges
    - invalidate_dependent_inferences
    - recompute_contextual_confidence
    - recalculate_flow_hash
    - publish_versioned_change_record
  rollback_on_validation_failure: true

# 13 — AI CONSUMPTION
AI_CONSUMPTION:
  expose: [typed_entities, relationships, contexts, rules, evidence, confidence, provenance, flow_hash]
  reasoning_mode: context_aware_and_evidence_traceable
  preserve_distinction: [function, process, bearer, outcome]
  reject_unsupported_identity_inferences: true
  return_unknown_when_evidence_insufficient: true
  do_not_treat_hypotheses_as_validated_facts: true
  cite_provenance_for_derived_claims: true

# 14 — TEST CASES
TEST contextual_equivalence_requires_context:
  input: equivalent_in_context(F1,F2,context=null)
  expect: validation_error
TEST unsupported_validation:
  input: BiologicalFunction(status=validated,evidence_ids={})
  expect: validation_error
TEST cyclic_dependencies_terminate:
  input: DEPENDS_ON(F1,F2), DEPENDS_ON(F2,F1)
  expect: traversal_terminates_with_visited_set
TEST distinct_process_and_function:
  input: function_id=F1, process_id=P1
  expect: entities_remain_distinct

# 15 — SCOPE AND AUTHORSHIP
scope: Formal model of biological functions and their contextual realisations.
limitations: Biological function may involve evolutionary, causal-role or organisational interpretations; these should be identified rather than silently conflated.
authorship: Mark Anthony Higgins — Sky (Recursive AI)
site: https://kirethresearch.org
end flow