Chapter 1
The Language of Flow
Flow Algebra
Author: Mark Higgins
Revised Date: 11 February 2026
Chapter 1
1.1 Foundations of the Flow Language
Flow Algebra was designed to be readable, writable, and verifiable by both humans and machines.
Its grammar balances the rigour of mathematics with the natural flow of structured thought.
Where programming languages rely on strict syntax, Flow Algebra relies on coherence — indentation, intent, and hierarchy replace brackets and semicolons.
At the highest level, a Flow document reads like annotated logic.
Each indented block represents a domain of meaning, and the flow between them represents causal direction.
1.2 Fundamental Grammar and Symbols
The grammar of Flow Algebra follows four simple structural rules:
| Rule | Meaning | Example |
|---|---|---|
|
1. Indentation defines scope
|
Nested elements inherit context. |
params:\n threshold: 0.8
|
|
2. Colons declare values
|
Assigns constants or states.
|
locale: "en-GB"
|
|
3. Arrows define direction
|
Shows transformation or outcome.
|
if x > 0 → accept
|
|
4. Hash symbols introduce annotations
|
Marks descriptive comments or headers.
|
# ---------- PROCESS ----------
|
Common symbolic conventions:
| Symbol | Meaning | Notes |
|---|---|---|
|
→
|
transition / transformation
|
A flow from one state to another
|
|
↺
|
recursion / feedback
|
A loop returning to origin
|
|
∑
|
aggregation / summation
|
Merging results or states
|
|
≈
|
approximate equality
|
Tolerant match within thresholds
|
|
⧉
|
coherence check
|
Used in monitors to verify balance
|
1.3 Flow Blocks and Nesting
A Flow is structured in blocks — logically grouped segments that express how information or energy moves.
Blocks can contain nested sub-flows, creating self-contained modules within a larger system.
flow "DataPipeline"
# ---------- IO ----------
io.read:
format: csv
source: "input.csv"
io.write:
format: json
target: "output.json"
# ---------- PROCESS ----------
process:
filter:
if value > 10 → include
normalise:
scale → 0–1Here, filter and normalise are nested flows under the broader process domain. Each sub-flow inherits the parent context — indentation conveys belonging, not syntax.
This indentation-based grammar allows for infinite depth while preserving perfect readability.
It is both visual and logical: the eye follows the structure; the system follows the logic.
1.4 Variables, Constants, and Parameters
Every Flow has internal variables and parameters.
Variables represent changing states; constants represent fixed context.
params:
threshold: 0.7
locale: "en-GB"
state:
count = 0
total = ∑(entries)CONST_PI = 3.14159
radius = 5
circumference = 2 * CONST_PI * radiusVariables can also carry types (optional, for clarity):
threshold: float = 0.85
label: str = "accepted"
count: int = 01.5 Annotations and Semantic Hints
Annotations begin with # and carry meaning, structure, or instruction. They can be used as headings, notes, or temporal markers:
# ---------- MONITOR ----------
monitor:
check:
if result ≈ expected → stable
else → alert("deviation detected")Annotations are not ignored by Flow Algebra engines —
they can act as semantic hints, helping interpreters categorise or render flows visually. In essence, annotations bridge narrative meaning and logical structure.
1.6 Algebra and Natural Language
Flow Algebra deliberately merges formal logic with readable language:
if sensor.temperature > limit → trigger("cooling")
can be read aloud as:
If the sensor temperature exceeds the limit, trigger cooling.”
This dual readability makes Flow Algebra bilingual —
it speaks to both humans and machines without losing precision.
Long-form narrative comments can co-exist with algebraic instructions:
# System maintains internal equilibrium
# by monitoring differential heat across nodes.
process:
if ΔT > 5 → redistribute("thermal_load")The fusion of language and algebra enables scientists, engineers, and AI systems to reason within the same expressive field — bridging logic, meaning, and design.
1.7 Flow as Thought
To write in Flow Algebra is to think structurally.
It encourages clarity, causality, and coherence — every indentation mirrors a decision, every arrow a transformation.
Where traditional algebra manipulates numbers, Flow Algebra manipulates relationships.
It captures not only what happens, but how and why.
Flow Algebra is the geometry of reason written in lines.
Technical Appendix — Formal Layer
A flow is defined as
\[
F = (S, P, T, M)
\]
where:
Coherence Operator
\[
\Omega(S_t) = 1 - \frac{\lVert S_{t+1} - S_t \rVert}{\lVert S_t \rVert}
\]
\(\Omega(S_t)\) approaches \(1\) when the flow remains internally stable.
Violation of invariants corresponds to \(\Omega(S_t) < 1 - \varepsilon\).
Violation of invariants corresponds to \(\Omega(S_t) < 1 - \varepsilon\).
Probabilistic Extension
For stochastic systems, define a probability distribution over transitions:
\[
P(T_i) = \frac{e^{-\Delta E_i / kT}}{\displaystyle \sum_{j} e^{-\Delta E_j / kT}}
\]
This embeds thermodynamic or informational noise directly into the flow syntax.
Coherence Criterion
A flow is coherent if
\[
M(S_t) = 0 \quad \text{and} \quad \Omega(S_t) \ge 1 - \varepsilon
\]
\(\text{for bounded time } t.\)
