Flow Algebra Entity Ontology

FLOW ALGEBRA
Flow Algebra Entity Ontology
Version: 1.0
Date: 2026-10-15
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/ai-semantic-library-mathematical-entities/flow-algebra-entity-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Project: Kireth Research Semantic Library

PURPOSE
Represent Flow Algebra expressions, operators, typed entities, relations, constraints and executions as inspectable mathematical entities in a semantic graph. This is a proposed formalisation, not a claim that a general-purpose execution engine has verified these definitions.

ENTITY TYPES
FlowEntity := {id, type, label, definition, domain, version, provenance}
FlowExpression := {id, operator, operands[], result_type, preconditions[], postconditions[]}
FlowOperator := {id, signature, semantics, constraints}
FlowRelation := {subject, predicate, object, context, evidence}
FlowExecution := {expression_id, input_bindings, output, status, trace}
FlowValidation := {target_id, checks[], result, evidence}

TYPE SYSTEM
Types = {Number, Boolean, Symbol, Equation, Set, Function, Relation, Graph, Unit, Constant, Proof, Flow, Unknown}
Judgement: Γ ⊢ e : τ
Rule: Γ ⊢ e_i : τ_i for all operands i AND signature(op) = (τ_1,...,τ_n) -> τ implies Γ ⊢ op(e_1,...,e_n) : τ.
Type mismatch -> INVALID, unless an explicit, validated coercion exists.
Unknown type -> UNRESOLVED, not VALID.

GRAPH MODEL
G = (V, E, T, P)
V = typed entities; E = directed, typed relations; T = type declarations; P = provenance records.
Relations: HAS_OPERAND, USES_OPERATOR, PRODUCES, DEPENDS_ON, EQUIVALENT_TO, DERIVED_FROM, VALIDATED_BY, CONSTRAINED_BY, VERSION_OF, REPRESENTS.
Every graph edge must reference existing node identifiers and an allowed predicate signature.

CORE OPERATIONS
CREATE_ENTITY(type, definition, context) -> FlowEntity
LINK_ENTITY(subject, predicate, object) -> FlowRelation | ERROR
COMPOSE(f, g) -> h, where codomain(g) is compatible with domain(f), h(x)=f(g(x))
EVALUATE(expression, bindings) -> value | UNRESOLVED | ERROR
NORMALISE(expression, rewrite_rules) -> canonical_candidate
VALIDATE(expression, constraints) -> FlowValidation
RESOLVE(identifier, context) -> candidate_set with evidence
TRACE(expression) -> ordered dependency and transformation records

INVARIANTS
I1: Every entity has a stable identifier and explicit type.
I2: Every operator application satisfies its declared arity and type signature.
I3: Referenced dependencies must exist or be explicitly marked unresolved.
I4: Rewrite rules preserve meaning only under their stated assumptions.
I5: A successful computation is not automatically a mathematical proof.
I6: Cyclic dependencies require explicit fixed-point or recursive semantics.
I7: Provenance is append-only within an immutable version.

SEMANTIC_EQUIVALENCE
Equivalent(a,b | Γ) requires a declared equivalence notion and evidence.
Syntactic identity: identical normalised representation.
Algebraic equivalence: equality under valid transformation rules and assumptions.
Extensional equivalence: same outputs on a specified domain (requires proof or appropriately qualified evidence).
Approximate equivalence: distance(a,b) <= ε under an explicitly chosen metric; do not promote to exact equivalence.

CONFIDENCE
ConfidenceRecord := {claim, score, method, evidence, calibration, scope}
score in [0,1] is an evidence assessment, not a substitute for proof.
Formal proof checked against stated axioms -> proof_status=VERIFIED.
Sampling or heuristic matching -> proof_status=UNVERIFIED, regardless of confidence score.
Unspecified evidence -> confidence=UNKNOWN.

VALIDATION
validate_graph(G): check IDs, references, relation signatures, versions and provenance.
validate_flow(F): check operand types, operator preconditions, dependencies and termination policy.
validate_result(R): check postconditions, domain constraints and unit consistency.
Statuses = {VALID, INVALID, UNRESOLVED, NOT_CHECKED}.

FLOW_HASH
FLOW_HASH(F) := SHA-256(canonical_serialisation(F))
Canonicalisation must fix key order, character encoding (UTF-8), numeric representation, namespace and version.
Hash equality establishes serialisation identity, not mathematical equivalence or truth.

UPDATE_MODEL
UPDATE(old, patch) -> new_version
Preconditions: patch is authorised; schema migration is declared; prior version is retained.
Postconditions: new hash computed; dependent validations marked STALE; provenance links old and new versions.
Conflict -> preserve competing versions pending explicit resolution.

AI_CONSUMPTION
Input: structured entity graph and optional natural-language question.
1. Identify target entities and context.
2. Resolve identifiers without silently merging ambiguous entities.
3. Check type signatures, constraints, assumptions and provenance.
4. Construct a traceable expression or inference path.
5. Execute permitted deterministic operations or label unsupported operations.
6. Return result with validation status, confidence basis, dependencies and version/hash.
7. Distinguish proved, computed, estimated and unresolved claims.

EXAMPLE
Entities: x:Number; two:Constant(Number, 2); add:Operator(Number,Number -> Number).
Expression: e = add(x,two).
Binding: x=3.
Evaluation: e=5.
Type judgement: Γ ⊢ e:Number.
Trace: x=3 -> add(3,2) -> 5.
Validation: VALID for declared arithmetic assumptions.

INTEROPERABILITY
Related ontologies: Mathematical Entity Relationship, Provenance, Confidence, Validation, Equivalence, Resolution, Cross-Domain Mathematical Entity, Equation Entity Graph, Symbol Entity Graph, Unit Entity Graph, Constant Entity Graph.
Exports: UTF-8 TXT; optional RDF/JSON-LD representations when separately mapped and validated.

LICENCE
Open research and educational reuse; preserve provenance and distinguish original claims from later modifications.