[Intro - single pulse, LEDs waking one by one]

Tick.

(one)

Tick.

(two)

Tick.

(four)

Tick.

(eight)

[relay click]

Count what arrives.
Remember what passed.
Expose the joint.
Patch the path.

[Verse 1 - dry clock percussion, binary bass enters]

I thought I had a divider,
a number cut in two,
a little row of outputs
telling clocks what clocks should do.

But underneath the package,
between the five and two,
there was a wire pretending
it was something it must do.

Pull the wire.
Make it visible.
Put a socket in its place.

Now the circuit has a question.

Where does the next event go?

[Refrain - clipped backing voices]

Count.
Observe.
Recognise.
Intervene.

(count)
(observe)
(recognise)
(intervene)

[Verse 2 - /10, /12 and /16 cycles phase against one another]

Two times five.

(ten)

Two times six.

(twelve)

Two times eight.

(sixteen)

Three little counting species
in three metrical worlds,
but the boundary of the package
is not the boundary of the thought.

Take the two from the decimal.
Give it to the twelve.
Let the binary clear the decade.
Let the decade clock itself.

The patch defines the machine.

(the patch defines the machine)

[Instrumental - counters cross-patched, divisions slowly misalign]

[Verse 3 - increasingly syncopated]

QA says now.
QB says later.
QC remembers
what QA forgot.

AND says together.
NOT says never.
RESET says:

[hard silence]

Start again.

[Drop - all counters restart on one pulse]

One.

(one)

One two.

(one two)

One two three four.

(one two three four)

Count until the condition is true.

Then destroy the history.

[Chorus - wide mechanical harmony, driving sub-bass]

Count, observe, recognise, intervene,
state becomes cause in the counting machine.

Count, observe, recognise, intervene,
the wire is the program,
the rhythm is seen.

No algorithm hiding
behind a little screen.

The patch defines the machine.

(the patch defines the machine)

[Verse 4 - unstable ripple percussion]

Between zero and one
there are things that shouldn't happen.

Between seven and eight
the bits do not agree.

A state that never existed
appears for just a moment.

Engineers call it a glitch.

We give it somewhere to go.

[Breakdown - propagation clicks moving across stereo field]

Not error.

(event)

Not noise.

(state)

Not failure.

(history)

A small causal machine
taking finite time
to become
its next
number.

[spoken]

Do not expose the pin
because the pin exists.

Expose the point
where a cable
can change causality.

[Build - clocks return one at a time]

Counter A clears B.

Counter B clocks C.

Counter C waits.

Counter C speaks.

Counter C clears A.

[brief silence]

Again.

[Bridge - voice becomes more human, machine remains strict]

An ordinary divider until patched.

A counting computer once patched.

No menu.
No preset.
No feature called strange.

Just state
meeting state
through a cable
and becoming change.

[Counterpoint - whispered voices circulating]

(/2)
(/5)
(/2)
(/6)
(/2)
(/8)

(reset)

(/2)
(/5)
(/2)
(/6)

(reset)

(reset)

(reset)

[Final Chorus - dense deterministic polyrhythm]

Count, observe, recognise, intervene,
state becomes cause in the counting machine.

Count, observe, recognise, intervene,
history erased where the states coincide.

Cross every species.
Break every seam.
Let intermediate moments
escape from the machine.

The package is not the boundary.
The output is not the end.
Every cable rewrites
what can cause what next.

[Outro - rhythms progressively stripped back to one clock]

Build the instrument.

Discover its language.

Build the instrument.

Discover its language.

[long pause]

Tick.

(Where does the next event go?)