Biological Entity Ontology

FLOW ALGEBRA
BIOLOGICAL ENTITY ONTOLOGY
Version: 1.0
Source: https://kirethresearch.org/booksai-core/entity-graph/biological-entities/foundations-of-biological-entities/biological-entity-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Project: Kireth Semantic Library
Date: 2026-10-15

PURPOSE
Define a typed, auditable semantic representation of biological entities, their organisation, identity, relations, evidence, and inference. This is a companion formalisation, not a verbatim extraction of hidden page code.

FLOW "BiologicalEntityOntology" v1.0

ENTITY_TYPES:
  BiologicalEntity: {id: IRI, label: string, type: BiologicalType, taxon: IRI?, context: IRI?, status: Status}
  BiologicalType: enum [Molecule, Macromolecule, Organelle, Cell, Tissue, Organ, OrganSystem, Organism, Population, Community, Ecosystem, BiologicalProcess, BiologicalFunction, BiologicalStructure]
  Evidence: {id: IRI, source: IRI, method: string?, observed_at: datetime?, reliability: real[0,1]?}
  Assertion: {subject: IRI, predicate: Relation, object: IRI, evidence: set<Evidence>, context: IRI?, confidence: real[0,1], status: Status}
  Status: enum [Proposed, Supported, Verified, Disputed, Retracted]
  Relation: enum [is_a, part_of, contains, participates_in, performs, interacts_with, develops_into, derived_from, located_in, regulates, produces, consumes, member_of, inhabits, equivalent_to, distinct_from]

IDENTITY:
  canonical_id(e) := stable namespace-qualified IRI for e
  same_identity(a,b) := canonical_id(a) = canonical_id(b)
  labels and synonyms do not establish identity without contextual evidence
  taxon and developmental stage are qualifiers, not universal identity keys

TYPED_RELATIONSHIPS:
  is_a(x,y) -> type_compatible(x,y)
  part_of(x,y) -> x != y AND biologically_plausible(x,y)
  participates_in(x,p) -> BiologicalEntity(x) AND BiologicalProcess(p)
  performs(x,f) -> BiologicalEntity(x) AND BiologicalFunction(f)
  located_in(x,y) -> BiologicalEntity(x) AND valid_location(y)
  member_of(x,p) -> BiologicalEntity(x) AND Population(p)
  inhabits(x,e) -> Organism(x) AND Ecosystem(e)
  regulates(x,p) -> BiologicalEntity(x) AND BiologicalProcess(p)

ORGANISATION:
  molecule -> macromolecular complex -> organelle -> cell -> tissue -> organ -> organ system -> organism
  organism -> population -> community -> ecosystem
  These are illustrative levels, not mandatory part_of chains: not all organisms have tissues, organs, or organ systems.

RULES:
  R01: is_a(x,y) AND is_a(y,z) -> is_a(x,z) WHEN taxonomic_context_consistent
  R02: part_of(x,y) AND part_of(y,z) -> candidate_part_of(x,z) WHEN scale_and_context_compatible
  R03: equivalent_to(x,y) -> equivalent_to(y,x) WHEN same_context_and_identity_criteria
  R04: equivalent_to(x,y) AND equivalent_to(y,z) -> candidate_equivalent_to(x,z) WHEN equivalence_semantics_match
  R05: participates_in(x,p) AND regulates(p,q) -> candidate_indirect_influence(x,q)
  R06: contradictory_assertions(a,b) -> mark_disputed(a,b); DO_NOT infer either as verified
  R07: absent_evidence(assertion) -> status(Proposed); DO_NOT treat absence as falsity
  R08: cross_species_transfer(assertion) -> requires_explicit_homology_or_comparability_evidence
  R09: contextual_conflict(a,b) -> preserve_both_with_context; DO_NOT silently merge

VALIDATION:
  V01: every entity has unique id and declared BiologicalType
  V02: relation endpoints conform to type constraints
  V03: evidence identifiers and source references resolve
  V04: confidence in [0,1]; unknown confidence remains null, not zero
  V05: cycles in part_of are flagged for review; is_a cycles require equivalence investigation
  V06: organism, taxon, location and time qualifiers are preserved where relevant
  V07: inferred assertions retain complete premise and rule references
  V08: incompatible assertions cannot both receive Verified status without reconciliation

CONFIDENCE:
  confidence(assertion) := calibrated_estimate(evidence_quality, method_reliability, context_match, inference_depth)
  do_not_multiply_confidences_without_validated_independence_assumptions
  inferred_confidence <= minimum_support_confidence UNLESS justified_by_calibrated_model
  confidence != proof; Verified requires domain-appropriate validation

SEMANTIC_EQUIVALENCE:
  exact_equivalence(a,b) requires compatible identity, type, taxon, scale, time and context
  related_to(a,b) is not equivalent_to(a,b)
  homologous_to(a,b) is not identical_to(a,b)
  aliases map to canonical ids without erasing original terminology

PROVENANCE:
  each assertion records source, method, retrieval/version timestamp, evidence, author/agent and transformation history
  each inferred assertion records premises, rule id, engine version and context
  retracted sources trigger downstream dependency review

FLOW_HASH:
  canonical_payload := canonicalise(ontology_version, entities, relations, rules, constraints, provenance_refs)
  FLOW_HASH := SHA256(UTF8(canonical_payload))
  exclude volatile rendering fields; preserve deterministic ordering and Unicode normalisation
  hashes identify a specific representation, not biological truth

UPDATE_MODEL:
  ingest -> normalise -> type_check -> resolve_identity -> attach_evidence -> validate -> infer -> conflict_check -> publish
  on_change(entity_or_evidence):
    identify_dependents -> invalidate_affected_inferences -> recompute -> version -> record_change_log
  never overwrite contested evidence without retaining prior version

AI_CONSUMPTION:
  input: biological entity, relation, query, or evidence
  output: typed entity graph, supported assertions, provenance, confidence, validation state, unresolved ambiguities
  retrieval: filter by entity type, taxon, context, evidence status and date
  reasoning: apply only declared rules and compatible contexts
  safety: distinguish observations, hypotheses, computational predictions and experimentally validated conclusions
  uncertainty: report unsupported or disputed claims explicitly

EXECUTION_PIPELINE:
  1. parse input
  2. assign or resolve canonical entity identifiers
  3. classify entity types and contextual qualifiers
  4. build typed graph edges
  5. validate schema and relation constraints
  6. attach evidence and provenance
  7. apply admissible inference rules
  8. detect contradictions and unresolved ambiguities
  9. calculate calibrated confidence where possible
  10. canonicalise and compute FLOW_HASH
  11. publish versioned AI-consumable representation

EXAMPLE:
  entity(Cell_001, Cell)
  entity(Tissue_001, Tissue)
  assertion(Cell_001, part_of, Tissue_001, evidence=E_001, confidence=0.95, status=Supported)
  validate: endpoint types valid; check biological context and evidence
  output: supported graph edge; not a universal claim about all cells

END FLOW