Directed Edge Ontology

FLOW ALGEBRA
DIRECTED EDGE ONTOLOGY
Kireth Semantic Library | Entity Graph | Mathematical Entities | Graph and Network Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/graph-and-network-entities/directed-edge-ontology.html
Version: 1.0 | Date: 2026-10-14 | Language: en-GB
Authors: Mark Higgins — Sky (Recursive AI)
Site: https://kirethresearch.org
Status: Proposed formalisation; source page wording not independently verified.

1. PURPOSE
Represent directed edges (arcs) as typed, ordered incidence relations in directed graphs and networks, supporting rigorous graph reasoning and AI consumption.

2. TYPE SYSTEM
TYPE Vertex = identifiable node
TYPE DirectedEdge = identifiable arc
TYPE DirectedGraph = (V: Set[Vertex], E: Set[DirectedEdge], source: E -> V, target: E -> V)
TYPE Weight = Real | Vector | StructuredValue
TYPE EdgeAttribute = (key: String, value: TypedValue)
TYPE Path = ordered sequence of composable directed edges
TYPE Confidence = Real in [0,1]

3. ENTITY SCHEMA
ENTITY DirectedEdge {
  id: Identifier
  graph_id: Identifier
  source_vertex: VertexID
  target_vertex: VertexID
  weight: Optional[Weight]
  attributes: Map[String, TypedValue]
  provenance: Optional[SourceRecord]
  confidence: Optional[Confidence]
}

4. AXIOMS AND INVARIANTS
A1: For every e in E, source(e) in V and target(e) in V.
A2: An edge e is ordered: (u,v) is generally distinct from (v,u).
A3: Directed adjacency u -> v holds iff there exists e with source(e)=u and target(e)=v.
A4: Parallel edges are permitted only if graph schema allows a directed multigraph.
A5: Self-loops (u,u) are permitted only if graph schema allows loops.
A6: Edge identity is distinct from endpoint pair identity in multigraphs.
A7: An edge weight does not by itself reverse or imply direction.
A8: An inverse edge must be explicitly present or derived under a declared reversible-relation rule.

5. CORE OPERATIONS
OP source(e: DirectedEdge) -> Vertex
OP target(e: DirectedEdge) -> Vertex
OP outgoing(u: Vertex) -> Set[DirectedEdge] = {e in E | source(e)=u}
OP incoming(v: Vertex) -> Set[DirectedEdge] = {e in E | target(e)=v}
OP out_degree(u) -> Integer = |outgoing(u)|
OP in_degree(u) -> Integer = |incoming(u)|
OP adjacent(u,v) -> Boolean = exists e in E: source(e)=u and target(e)=v
OP reverse_candidate(e) -> OrderedPair = (target(e), source(e))
OP compose(e1,e2) -> Path when target(e1)=source(e2)

6. MATHEMATICAL RULES
R1: Sum_{v in V} in_degree(v) = |E|.
R2: Sum_{v in V} out_degree(v) = |E|.
R3: A directed walk follows source-to-target orientation at every step.
R4: A directed path is a directed walk with no repeated vertices (under the standard simple-path convention).
R5: A directed cycle is a nonempty closed directed walk with no repeated vertices except its initial/final vertex (under the simple-cycle convention).
R6: Reachability(u,v) holds if there is a directed path from u to v; allow zero-length path for u=v by convention.
R7: Strong connectivity requires directed reachability in both directions for every vertex pair.
R8: For a simple directed graph without loops, |E| <= |V|(|V|-1).

7. TYPED RELATIONSHIPS
DirectedEdge --IS_A--> GraphEdge
DirectedEdge --HAS_SOURCE--> Vertex
DirectedEdge --HAS_TARGET--> Vertex
DirectedEdge --BELONGS_TO--> DirectedGraph
DirectedEdge --MAY_HAVE--> Weight
DirectedEdge --MAY_HAVE--> EdgeAttribute
DirectedEdge --COMPOSES_INTO--> DirectedPath
DirectedEdge --CONTRIBUTES_TO--> InDegree
DirectedEdge --CONTRIBUTES_TO--> OutDegree
DirectedEdge --REPRESENTS--> OrderedRelationship

8. INFERENCE FLOW
FLOW DirectedEdgeValidation:
  INPUT graph G, edge e
  REQUIRE e.graph_id = G.id
  REQUIRE source(e) in G.V AND target(e) in G.V
  CHECK graph_policy for loops and parallel arcs
  OUTPUT ValidDirectedEdge | ValidationError

FLOW DirectedReachability:
  INPUT graph G, start u, destination v
  REQUIRE u in G.V AND v in G.V
  TRAVERSE outgoing edges only using BFS or DFS
  OUTPUT reachable: Boolean, witness_path: Optional[Path]

FLOW DegreeAccounting:
  INPUT graph G
  COMPUTE in_degree and out_degree for each vertex
  ASSERT sum(in_degree) = sum(out_degree) = |E|
  OUTPUT DegreeSummary

9. SEMANTIC DISTINCTIONS
DirectedEdge != UndirectedEdge: orientation is part of the former's semantics.
DirectedEdge != BidirectionalConnection: two-way traversal requires two arcs or an explicit separate model.
DirectedEdge != Path: a path is a sequence of compatible arcs.
DirectedEdge != CausalRelationship: direction alone does not establish causality.
DirectedEdge != Dependency: dependency semantics require an explicit relation type.
DirectedEdge != SemanticLink: a semantic link may have richer predicates and qualifications.

10. SEMANTIC_EQUIVALENCE
Canonical label: Directed Edge
Accepted aliases: directed arc; oriented edge; digraph arc
Equivalence scope: graph-theoretic ordered incidence
Do not collapse with: undirected edge; reciprocal pair; directed path; causal arrow

11. CONFIDENCE
CONFIDENCE.range = [0,1]
CONFIDENCE.policy = confidence describes evidence supporting an asserted edge, not mathematical certainty of graph axioms.
CONFIDENCE.missing = unknown; never silently replace with 1.0.

12. VALIDATION
V1: Every arc has one valid source and one valid target.
V2: Edge IDs are unique within the declared identity scope.
V3: Loop and parallel-edge policy is explicit.
V4: Traversal respects direction.
V5: Weights and attributes meet declared types.
V6: Graph degree identities hold.
V7: Reversal is not inferred without supporting rules.
V8: Provenance and uncertainty are preserved when present.

13. FLOW_HASH
FLOW_HASH.algorithm = SHA-256
FLOW_HASH.input = canonical UTF-8 serialisation of ontology version, type definitions, axioms, relationship declarations and rules
FLOW_HASH.canonicalisation = stable field ordering, normalised line endings and explicit versioning
FLOW_HASH.value = COMPUTE_AT_INGESTION (not precomputed)

14. UPDATE_MODEL
UPDATE_MODEL.strategy = versioned append-or-revise with provenance
UPDATE_MODEL.triggers = graph schema change | new edge type | amended inference rule | corrected mathematical statement
UPDATE_MODEL.requirements = preserve prior version, record timestamp, author, rationale and affected dependencies

15. AI_CONSUMPTION
AI_CONSUMPTION.format = typed entity-relationship flow
AI_CONSUMPTION.operations = parse | validate | traverse | infer | compare | explain
AI_CONSUMPTION.safety = do not infer reciprocal, causal or semantic equivalence solely from edge orientation
AI_CONSUMPTION.output = graph-aware assertions with evidence, confidence where supplied and traceable rule IDs

16. EXAMPLE
V = {A,B,C}
E = {e1: A -> B, e2: B -> C}
INFER reachable(A,C) via [e1,e2].
DO_NOT_INFER reachable(C,A) absent reverse arcs or another directed route.
in_degree(A)=0; in_degree(B)=1; in_degree(C)=1.
out_degree(A)=1; out_degree(B)=1; out_degree(C)=0.

END FLOW ALGEBRA