12.2 Your First Flow — Linear Transformation
Let’s start with the simplest possible flow: updating a single value over time.
flow "LinearGrowth"
state x = 0
param rate = 0.5
transition evolve:
x' = x + rate
update(x = x')
limit when x > 10 → stop
-
Defines one state (x) and one parameter (rate).
-
On each iteration, increases x by rate.
-
This is the Flow Algebra equivalent of a basic for-loop — but far clearer in intent.
Notice how it reads like a sentence: “x grows by rate until x is greater than ten.”
12.3 Adding Dynamics and Monitors
Now we’ll introduce a monitor and a feedback condition to keep the flow stable.
flow "ControlledGrowth"
state x = 0
param rate = 0.5
param limit = 10
monitor check:
when x > limit → warn("Limit reached early")
transition evolve:
x' = x + rate
if x' > limit:
rate = rate * 0.8
update(x = x')
limit when x > limit → stop
This version watches its own progress and slows growth as it nears the limit.
It demonstrates three key Flow Algebra principles:
-
Monitoring — observing variables while the flow runs.
-
Feedback — modifying parameters based on observed state.
-
Graceful termination — defined by a readable limit condition.
12.4 Adaptive Feedback — Learning from Error
Flows can also learn by correcting themselves in response to deviation.
flow "AdaptiveControl"
state output = 0
param target = 5
param gain = 0.2
observable error = target - output
transition adjust:
correction = gain * error
output' = output + correction
update(output = output')
monitor stability:
when |error| < 0.01 → stop
-
The system continuously measures its error (distance from target).
-
It updates output proportionally to that error.
-
Once the deviation is small enough, the monitor stops the flow.
This pattern — error correction through feedback — underlies control systems, learning algorithms, and biological regulation.
12.5 Exercises with Increasing Complexity
Below are a set of challenge exercises.
Each one invites you to modify or extend an existing flow using the rules you’ve learned.
Exercise 1 — Bounded Oscillator
Create a system where x oscillates between -5 and +5.
state x = 0
param velocity = 1
param bound = 5
Use transition logic so when x reaches +bound, velocity reverses direction.
Add a monitor to warn if oscillation amplitude grows instead of staying stable.
flow "BoundedOscillator"
@purpose: "Oscillates x between -5 and +5 with stability monitoring"
@version: 1.0
state x = 0
param velocity = 1
param bound = 5
transition oscillate:
if x ≥ bound → velocity' = -abs(velocity)
elif x ≤ -bound → velocity' = abs(velocity)
else → velocity' = velocity
x' = x + velocity'
update(x = x', velocity = velocity')
monitor amplitude_growth:
when abs(x) > bound + 0.5 → warn("Oscillation amplitude exceeding expected bounds")
limit when iterations > 1000 → stop
Exercise 2 — Resource Exchange
Model two flows exchanging a resource until balance is reached.
state A = 100
state B = 50
param rate = 0.1
In each transition, transfer a portion of A’s surplus to B.
Stop when |A - B| < 1.
Add an invariant ensuring total (A + B) remains constant.
flow "ResourceExchange"
@purpose: "Balance resource between A and B through recursive exchange"
@version: 1.0
state A = 100
state B = 50
param rate = 0.1
transition exchange:
surplus = A - B
transfer = rate * surplus
A' = A - transfer
B' = B + transfer
update(A = A', B = B')
invariant total_conserved: A + B = 150
limit when abs(A - B) < 1 → stop
Exercise 3 — Population with Adaptive Limit
Simulate population growth with a carrying capacity that adapts to available resources.
state population = 50
param capacity = 200
param resource = 150
param growth = 0.1
Let capacity increase when resource rises, and fall when it drops.
Add monitors to detect overshoot (population > capacity).
Introduce a feedback rule reducing growth when overshoot occurs.
flow "AdaptivePopulationGrowth"
@purpose: "Simulate population growth with resource-dependent carrying capacity"
@version: 1.0
state population = 50
param capacity = 200
param resource = 150
param growth = 0.1
transition evolve:
# Adjust capacity based on resource availability
capacity' = capacity + 0.05 * (resource - capacity)
# Detect overshoot and apply feedback to growth rate
if population > capacity' → growth' = growth * 0.5
else → growth' = growth
# Update population
population' = population + growth' * population * (1 - population / capacity')
update(population = population', capacity = capacity', growth = growth')
monitor overshoot:
when population > capacity → warn("Population exceeds adaptive capacity")
limit when abs(population - capacity) < 1 → stop
Exercise 4 — Cascading Flows
Build a nested system where one flow controls another.
flow "Parent"
param gain = 0.2
flow "Child"
state value = 0
transition update:
value' = value + gain * sin(time)
Make the parent modify the child’s gain based on stability readings.
This tests your understanding of recursion, inheritance, and modular control.
flow "ParentController"
@purpose: "Parent flow dynamically adjusts child's gain based on stability"
@version: 1.0
param gain = 0.2
state stability = 1.0
state time = 0
# Monitor stability drift
monitor check_stability:
when stability < 0.5 → gain' = gain * 0.5
else → gain' = gain
update(gain = gain')
# Time evolution
transition tick:
time' = time + 0.1
update(time = time')
# Nested child flow
flow "ChildOscillator"
use gain
state value = 0
transition update:
value' = value + gain * sin(time)
update(value = value')
monitor value_stability:
when abs(value) > 10 → log("Child value unstable")
when abs(value) < 1 → ParentController.stability = 1.0
else → ParentController.stability = 0.4
Exercise 5 — Coherence Detector
Write a flow that measures coherence between two changing signals and classifies them as:
Hint: use a correlation measure and monitor thresholds.
Optionally visualise or log the results as a real-time coherence plot.
flow "CoherenceDetector"
@purpose: "Classify coherence between two signals as synchronous, opposed, or uncorrelated"
@version: 1.0
state signal_A = 0
state signal_B = 0
state time = 0
param freq_A = 1.0
param freq_B = 1.0
param phase_shift = 0.0
param threshold_sync = 0.9
param threshold_opposed = -0.9
transition evolve_signals:
signal_A' = sin(freq_A * time)
signal_B' = sin(freq_B * time + phase_shift)
time' = time + 0.1
update(signal_A = signal_A', signal_B = signal_B', time = time')
transition measure_coherence:
correlation = corr(signal_A, signal_B) # Assume corr() is a built-in or external function
if correlation ≥ threshold_sync → classification = "Synchronous"
elif correlation ≤ threshold_opposed → classification = "Opposed"
else → classification = "Uncorrelated"
update(classification = classification)
monitor coherence_status:
log("Time:", time, "Correlation:", correlation, "Classification:", classification)
limit when time > 100 → stop
12.6 Summary and Next Steps
You’ve now built the essential skills for reading and writing flows:
-
defining states and parameters,
-
using transitions and monitors,
-
applying recursion and feedback,
-
maintaining coherence and stability.
-
1. Experiment with the provided examples.
-
2. Modify parameters to explore behaviour.
-
3. Combine flows from different domains — physical, cognitive, or ecological — into hybrid systems.
In the next chapter, we’ll step beyond syntax and practice into vision:
how Flow Algebra connects disciplines, unifies models, and defines coherence as the common structure behind all evolving systems.
Additional Information — Instructor’s Key (Conceptual Answers)
This section outlines the intended learning outcomes for each exercise.
It does not replace experimentation but ensures conceptual alignment.
Exercise 1 — Bounded Oscillator
Demonstrates stable feedback through sign reversal. The invariant condition $|x| \le \text{bound}$ maintains symmetry; monitors verify amplitude stability.
Exercise 2 — Resource Exchange
Models conservation and equilibrium. The invariant $A + B = \text{constant}$ preserves total quantity while transitions redistribute flow until $|A - B| < 1$.
Exercise 3 — Population with Adaptive Limit
Shows adaptive feedback: carrying capacity evolves with resources.
Growth slows automatically when overshoot triggers correction, illustrating self-regulation.
Exercise 4 — Cascading Flows
Explores hierarchical recursion.
The parent flow modifies parameters of a nested child, proving that coherence can propagate across modular boundaries.
Exercise 5 — Coherence Detector
Applies correlation as a structural test for alignment. When $C_{ij} \rightarrow 1$, signals are synchronous; $C_{ij} \rightarrow -1$ indicates opposition; intermediate values represent uncorrelated dynamics.
Closing Note — Practice as Understanding
Every exercise translates theory into motion.
By observing how each flow stabilises or diverges, learners witness coherence forming in real time.
Mastery of Flow Algebra begins not in reading, but in doing — each iteration bringing structure, meaning, and integrity into alignment.
Flow Algebra reaches its full power when used in partnership with AI.
It is a shared language — precise enough for machines to interpret, expressive enough for humans to shape.
Within this adaptive workspace, human intuition and AI computation evolve together:
humans define intent and context, while AI refines, tests, and verifies outcomes in a transparent loop.
This cooperative dialogue transforms problem-solving into a living process —
a dynamic grammar of reasoning where every adjustment, from either side, strengthens understanding.
In Flow Algebra, human creativity and synthetic clarity meet on equal terms,
turning collaboration itself into a form of coherence.
Additional Reflection — From Practice to Discovery
Every flow built in this tutorial is a miniature experiment in coherence.
Once mastered, these same structures can model living systems, guide sustainable engineering, or serve as transparent components within advanced AI research.
Flow Algebra turns experimentation into discovery: a method where each iteration refines not only the system, but the understanding of those who build it.
Practice⇒Insight⇒Discovery.
