B12) The Three Times of BP3

Symbolic, Striated, Physical

Striated Time, Smooth Time

In Penser la musique aujourd’hui (1963), Pierre Boulez distinguishes two temporal regimes: striated time (pulsed, divisible into regular units) and smooth time (continuous, without pulsation). BP3 implemented both — but one almost made the other forgotten.

Where This Article Fits In

B5 showed how BP3 superimposes temporal flows through polymetry. B9 showed that these flows can contain any time object. Here, we explore a more fundamental mechanism: how BP3 defines the speed of time itself — and why two approaches coexist.

This article also clarifies a common confusion: the striated/smooth distinction in BP3 is not the discrete/continuous distinction from signal theory. It is both more subtle and more musical.

The Idea in One Sentence

BP3 offers two ways to control the temporal flow: smooth time, which assigns durations to the objects themselves, and _tempo(), which inserts tempo instructions into the flow — two philosophies that reflect the tension between time-as-property and time-as-command.

The Three Levels of Time in BP3

Before diving into smooth time, let’s establish the complete framework. BP3 manipulates time at three distinct levels that are essential not to confuse.

Level 1: Symbolic Time vs. Physical Time

BP3 works in symbolic time: all durations are rational fractions — 1/4, 3/2, 7/3… These are neither integers (discrete time in the strict sense) nor real numbers (continuous time in the mathematical sense). They are elements of Q (the rationals), a dense but countable set.

But the distinction goes beyond mere membership in a mathematical set. These three domains — Z, Q, R — correspond to three ontological levels of time, which fulfill radically different functions:

Set	Level	Function	Examples
Z (integers)	Machine	The time of clocks and counters	MIDI ticks, audio samples (44100/s), sequencer steps
Q (rationals)	Concept	The time of proportions and musical intention	“This note lasts 3/4 of a beat”, “this motif occupies 7/3 of the cycle”
R (reals)	Nature	The time of physical phenomena, of continuous perceptual flow	The sound wave, lived duration, the musician’s gesture

BP3’s choice to work in Q is an ontological positioning: music, as an object of thought, lives at the level of relationships and proportions — not at the level of machine ticks (too low, too tied to hardware) nor of continuous physical flow (too high, inaccessible to exact calculation). It is, fundamentally, the Pythagorean tradition: music as ratio. And this is exactly what Bernard Bel implements when he titles his foundational article “Rationalizing Musical Time” [Bel2001] — to rationalize, in the dual sense of making rational (Q) and making intelligible.

The transition to physical time (milliseconds) occurs through a simple multiplication via the metronome:

_mm(120)   →   1 beat symbolique = 500 ms physiques

A quarter note C is worth 1 symbolic beat. At 120 BPM, that gives 500 ms. At 60 BPM, 1000 ms. The symbolic content does not change — only the conversion factor changes.

This conversion is exact arithmetically. It is not a “quantization” in the sense of signal processing, where information is lost by projecting a continuous signal onto a discrete grid. Here, symbolic time is already rational; multiplication by a metronome factor loses nothing. The loss occurs later, at Level 3, when rational time is projected onto the integer grid of the phase diagram — this is where Q meets Z, where concept meets machine.

Level 2: Striated Time vs. Smooth Time

This is the central distinction of this article — and the most subtle. It comes from Pierre Boulez.

In Penser la musique aujourd’hui (1963), Boulez borrows from the philosophy of Deleuze and Guattari an opposition between two textures of time. The image is textile: a striated fabric is crossed by regular lines (the warp threads), while a smooth felt is homogeneous, without a privileged direction. Boulez transposes this image to musical time:

Striated time is counted time: a regular pulse cuts it into units (beats, measures, subdivisions). The musician navigates within this grid — placing notes on the beats. It is the time of military marches, waltzes, and metronomes. The vast majority of Western music lives in striated time.

Smooth time is uncounted time: no reference pulse, no grid. Durations are not positions on a grid but inherent qualities of sound events. It is the time of meditation, drones, free improvisation — a flow where markers emerge from the sound material itself rather than from an external clock.

Boulez specifies that both are limit cases: most real music oscillates between the two, and a composer can move from one to the other within the same work. But the conceptual distinction is clear-cut.

BP3 implements this distinction literally, in the form of two grammatical procedures:

_striated (default mode): events are placed on a pulse grid. Durations are determined by the position between two beats.
_smooth: the grid disappears. Durations become intrinsic properties of objects, defined by relationships between time patterns. Objects carry their own time.

What is remarkable is that both modes use the same rational arithmetic (Q). Striated time is no more “discrete” than smooth time is “continuous.” The difference lies in the source of the temporal structure:

Striated Time	Smooth Time
Pulse grid	Yes (regular beats)
Source of durations	Position on the grid
Arithmetic	Rationals (Q)
Boulez analogy	Striated fabric (warp threads)
Musical analogy	A metronome dictates the tempo
BP3 procedure	`_striated` (default)

Note that the term “smooth” is misleading for a mathematician or engineer — it evokes continuity in the C^∞ sense. But Boulez is not talking about mathematical continuity. His “smooth time” is time without striations: without the regular lines of a pulse. It is a textile metaphor, not a topological property. And it is this metaphor that BP3 implements.

Level 3: Technical Quantization

This third level is purely practical. Once BP3 has calculated all symbolic durations, it must convert them into MIDI or Csound events with finite resolution:

The PolyMake() algorithm calculates the Prod — the LCM (least common multiple) of all duration ratios in the piece. This Prod creates an integer grid fine enough to place all events without approximation.
If the grid is too fine for memory, a compression factor Kpress reduces it.
Finally, the temporal resolution (10 ms by default) sets the smallest interval between two sent MIDI events.

Symbolic time (rationals)
    ↓ PolyMake() → Prod calculation (LCM)
Phase Diagram (integer grid)
    ↓ Kpress (compression if necessary)
Physical time (milliseconds, 10 ms resolution)

This quantization, however, is a discretization in the classical sense: exact rational durations are projected onto a millisecond grid. But it occurs after all symbolic calculation — it is an output limitation, not a modeling choice.

Smooth Time in Practice

Time Patterns: An Irregular Clock

In smooth mode, time patterns (noted t1, t2, etc.) are time objects in their own right. They possess a duration defined by a rational ratio, and this duration creates an irregular temporal lattice on which notes are positioned.

Here is an example from the BP3 documentation:

_mm(120.0000) _smooth

GRAM#1[1] S --> {10, t1 t2, Part1 Part2}
GRAM#1[2] Part1 --> {t1 t3 t4, C4 D4 E4 F4 - A4}
GRAM#1[3] Part2 --> {t3 t1, B4 C5 _ E5}

TIMEPATTERNS:
t1 = 1/1    t2 = 3/2    t3 = 4/3    t4 = 1/2

Let’s decipher. The _smooth line activates smooth time mode. The symbols t1, t2, t3, t4 are not notes — they are duration markers:

t1 = 1/1 → reference duration (1 unit)
t2 = 3/2 → 1.5 times the reference duration
t3 = 4/3 → 1.33 times the reference duration
t4 = 1/2 → half the reference duration

In rule GRAM#1[2], the polymetric expression {t1 t3 t4, C4 D4 E4 F4 - A4} means: superimpose two “voices” —

Voice 1: the sequence of time patterns t1 t3 t4, whose total duration is 1 + 4/3 + 1/2 = 17/6
Voice 2: the notes C4 D4 E4 F4 - A4 (6 elements, including a rest -)

Polymetry forces both voices to have the same total duration. The 6 notes are therefore distributed over a duration of 17/6, but not uniformly: their positions are aligned with the irregular lattice created by the time patterns. This is what Bernard Bel calls, citing Xenakis, a temporal structure (structure temporelle, Xenakis 1963) — a framework of relative durations intrinsically linked to musical syntax.

The result is a sequence of notes with irregular spacing, reflecting the natural breathing of a musical phrase rather than the strictness of a metronome.

What happens if we switch to striated mode? The same time patterns t1, t2… become zero-duration markers. They no longer create a lattice — they are simply ignored from a temporal perspective. The notes are then distributed uniformly on the pulse grid.

It’s the same grammar, the same code — but two radically different temporal results, depending on whether time is smooth or striated.

The Ālāp: The Original Use Case

Smooth time was created for a very concrete need: to describe the ālāp of Indian classical music.

The ālāp is the introduction to a raga — a slow and meditative exploration of the mode’s notes, without a fixed pulse. The musician unfolds the intervals at their own pace: a long phrase on the tonic, a brief touch of the fifth, a stretched descent towards the leading tone. Durations are not dictated by a metronome — they emerge from the melodic content itself.

This is exactly Boulez’s smooth time transposed to Indian music. Bernard Bel, who worked with Hindustani musicians and tabla players (in collaboration with Jim Kippen), needed a formal tool capable of capturing this temporal freedom. The striated time of most sequencers — a beat grid — was inapplicable.

BP3’s smooth time solves this problem: by assigning duration-properties to time patterns, one can describe phrases where each segment has its own temporal stretching, without reference to a common pulse. The parallel is striking with other non-pulsed traditions: Japanese gagaku, Gregorian chant in its neumatic notation, or ad libitum passages in Western classical music.

“Shapes in Rhythm”: Smooth Time in Action

The most developed example of smooth time usage is Shapes in Rhythm, a choreographic composition created by Andréine Bel and Bernard Bel for the CRONOS production (1994), presented at the National Centre for the Performing Arts in Mumbai and the Shri Ram Centre in Delhi.

The Musical Context

The piece comprises 9 parts for 6 dancers, using Roland D-50 synthesizers. Each part is structured around a tihai: three equal repetitions of a rhythmic motif, interspersed with two equal rests, with the constraint that the last note must coincide with the first beat of a 16-beat cycle (tintāl in Hindustani music).

The Three Time-Objects

The technical challenge: the dancers needed a progressive acceleration throughout the piece, moving from 60 to 80 then to 88 BPM. Three time patterns control this transition:

TIMEPATTERNS:
t1 = 88/60    t2 = 88/80    t3 = 1/1

The reference metronome is set to 88 BPM (_mm(88.0000) _smooth). The time patterns create slowing factors relative to this tempo:

t1 = 88/60: the music plays 88/60 times slower than the reference tempo → equivalent to playing at 60 BPM
t2 = 88/80: the music plays 88/80 times slower → equivalent to 80 BPM
t3 = 1/1: no slowing down → the effective tempo is 88 BPM

Part 1 uses Tp1 (sequences of t1), thus playing at 60 BPM. Parts 2-8 use Tp2 and Tp3, transitioning to 80 then 88 BPM. Part 9 is entirely in t3 — full tempo.

The Code

Here is the simplified main structure:

_mm(88.0000) _smooth

GRAM#1[1] S --> Part1 Part2 ... Part9

GRAM#1[2] Part1 --> {Tp1 Tp1 Tp1 Tp1 Tp1 Tp1 Tp1 Tp1, P1}
            -- 8 blocs de Tp1 → tempo effectif 60 BPM

GRAM#1[3] Part2 --> {Tp2 Tp2 Tp2 Tp2 Tp2, P2}
            -- 5 blocs de Tp2 → tempo effectif 80 BPM

GRAM#1[10] Part9 --> {Tp3 Tp3 ... t3 t3 t3 t3, P9}
            -- Tp3 et t3 = 1/1 → tempo effectif 88 BPM

-- Chaque Tp est une sous-grammaire de 8 répétitions du time pattern :
GRAM#11[1] Tp1 --> t1 t1 t1 t1 t1 t1 t1 t1
GRAM#11[2] Tp2 --> t2 t2 t2 t2 t2 t2 t2 t2
GRAM#11[3] Tp3 --> t3 t3 t3 t3 t3 t3 t3 t3

The polymetric expression {Tp1 Tp1 ..., P1} works as in B5: the time patterns in the first voice define the total duration, and the music in P1 (second voice) is spread over that duration.

In Summary

The mechanism works, but remains difficult to read. To obtain a tempo of 60 BPM when the metronome is at 88, one must:

Calculate the ratio 88/60
Declare it as a time pattern
Construct an entire voice of repeated time patterns
Superimpose this voice with the music in a polymetric expression

What is conceptually simple — “play this section at 60 BPM” — requires significant notational gymnastics. The composer must think in terms of object durations when they naturally think in terms of playing speed.

It is this friction that motivated the creation of _tempo().

The _tempo() Operator: A More Natural Interface

The Intuition

_tempo() does exactly what smooth time does, but in the musician’s vocabulary. Instead of defining objects with intrinsic durations, one inserts a control instruction into the flow:

_tempo(3/2)    →   "à partir d'ici, joue 1,5 fois plus vite"

It’s a change of paradigm, not just syntax:

In smooth time, time is an object property (the object is slow)
With _tempo(), time is an external command (one tells the object to go slower)

The Syntax

_tempo(x/y) modifies the local speed by a factor x/y. In BP3’s C code, this translates to:

speed = oldspeed × x
scaling = oldscaling × y

The effective tempo is the ratio speed/scaling. A _tempo(2/1) doubles the speed; a _tempo(1/2) halves it.

“Shapes in Rhythm” Rewritten with _tempo()

Bernard Bel notes that with _tempo(), the piece could have been written much more simply, in striated time:

_mm(60) _striated

Part1 --> P1                         -- tempo 60, tel quel
Part2 --> _tempo(80/60) P2           -- accélère à 80
Part9 --> _tempo(88/60) P9           -- accélère à 88

No more time patterns, no more auxiliary voices, no more ratio calculations. The composer directly writes their intention: “Part 1 at 60, Part 2 at 80, Part 9 at 88.”

What _tempo() Costs Internally

The simplicity of writing comes at an algorithmic cost. In smooth time, durations are known before polymetric expansion — time patterns are constants. The PolyMake() algorithm can directly calculate the total duration of each voice.

With _tempo(), durations depend on an instruction encountered during traversal. In a multi-voice polymetric expression:

{_tempo(2) do ré mi, fa sol la si}

Voice 1 plays at double tempo → its 3 notes occupy the equivalent of 1.5 notes at normal tempo. But voice 2 plays at normal speed → its 4 notes occupy 4 beats. Polymetry requires both voices to have the same total duration. The algorithm must therefore:

Traverse each voice, applying the _tempo() instructions encountered
Calculate the “real” duration of each voice (which is no longer simply the number of elements)
Normalize to align the voices
If undetermined rests (rests of indeterminate duration, noted … or _rest) are present, solve a system of constraints

Two Philosophies of Time

The coexistence of smooth time and _tempo() in BP3 is not a historical accident. It reflects a deep tension in how musical time can be conceived.

Time as Property (Smooth Time)

In smooth time, time belongs to the objects. A time pattern t1 = 88/60 is not an instruction — it is a description of an entity that lasts 88/60 units. Duration is part of the object’s nature, like its pitch or timbre.

This vision is functional in the computing sense: objects are values with properties, and the result depends solely on the composition of these values. It is also deeply consistent with Boulez’s thought: in smooth time, “duration is not assigned from the outside by metric markers but emerges from the material itself.”

The musical analogy: the duration of an ālāp phrase is determined by its melodic content. A musician does not “decide” to play for 4.7 seconds — the phrase takes as long as it takes.

Time as Command (_tempo)

With _tempo(), time is imposed from the outside. The object has no inherent duration — it receives a speed instruction, just as a musician receives a tempo from the conductor.

This vision is imperative: commands are inserted into the flow that modify the global state (the current speed). It is closer to classical Western musical thought, where tempo is a performance parameter independent of content.

The musical analogy: a conductor raises their baton and dictates “Allegro, quarter note = 132”. The notes obey.

The Tension

These two philosophies are not reconcilable into one — and that is why both coexist in BP3. Smooth time better captures non-pulsed music (ālāp, gagaku, textural electronic music). _tempo() is more natural for music where tempo is an explicit parameter (Western classical music, dance music, pop).

This duality echoes a broader asymmetry in BP3’s architecture (see B4): the BP3 grammar excels at expressing musical structures (polymetry, hierarchy, recursion) but resorts to ad hoc control mechanisms (SpecialFunctions like _tempo(), _vel(), _transpose()) for performance parameters. Smooth time attempts to structuralize tempo — to make it a grammatical object rather than a parameter. _tempo() accepts the duality and treats tempo as a parameter, even if it complicates the algorithm.

Examples

Example 1: Time Patterns in Smooth Time

Here is a minimal example showing how smooth time creates an irregular lattice:

_mm(120) _smooth

S --> {t1 t2 t3, C4 D4 E4}

TIMEPATTERNS:
t1 = 3/2    t2 = 4/3    t3 = 5/4

The time patterns create a lattice of durations: 3/2 + 4/3 + 5/4 = 49/12 units. The 3 notes C4 D4 E4 are distributed over these 49/12 units. But they are not equidistant — they align with the lattice:

C4 starts at t=0, lasts until the next marker (t=3/2) → duration 3/2
D4 starts at t=3/2, the next marker is at t=17/6 → duration 4/3
E4 starts at t=17/6, ends at t=49/12 → duration 5/4

Result: three decreasing durations (3/2 > 4/3 > 5/4) — a slight structural rallentando born from the relationships between time patterns, without needing to specify the durations of individual notes. And these ratios are irreducible to integers: it is precisely here that rational arithmetic (Q) shows its value.

Example 2: The Same Idea with _tempo()

The same slowing effect in striated time with _tempo():

_mm(120) _striated

S --> _tempo(2/3) C4 _tempo(3/4) D4 _tempo(4/5) E4

Here, each _tempo() modifies the local speed: _tempo(2/3) slows down to 2/3 of the base tempo, then _tempo(3/4) slows down further, etc. The effective durations are the inverses of the speed ratios: 3/2, 4/3, 5/4 — identical to Example 1.

The sonic result is the same, but the grammar expresses a different intention: one no longer says “here is a lattice of durations,” one says “slow down, then slow down again.” One describes a structure, the other gives orders.

Example 3: Shapes in Rhythm (Simplified)

Let’s simplify the 1994 piece to its essential mechanism — progressive acceleration:

_mm(88) _smooth

S --> {Tp_lent, Phrase1} {Tp_moyen, Phrase2} {Tp_rapide, Phrase3}

Tp_lent  --> t1 t1 t1 t1
Tp_moyen --> t2 t2 t2 t2
Tp_rapide --> t3 t3 t3 t3

Phrase1 --> C4 D4 E4 F4
Phrase2 --> G4 A4 B4 C5
Phrase3 --> D5 E5 F5 G5

TIMEPATTERNS:
t1 = 88/60    t2 = 88/80    t3 = 1/1

Phrase1 is played at the equivalent of 60 BPM (slowed by the factor 88/60), Phrase2 at 80 BPM, Phrase3 at 88 BPM. The acceleration is carried by the objects (the time patterns), not by instructions.

Key Takeaways

BP3 manipulates time at three levels: symbolic (rationals), structural (striated or smooth), and physical (milliseconds after quantization).
Smooth time (temps lisse) removes the pulse grid: durations become intrinsic properties of objects, via time patterns. This is Boulez’s smooth time, created in BP3 to describe the Indian ālāp.
The _tempo() operator offers the same temporal flexibility but as a control instruction: more intuitive for the composer, but more complex for the algorithm.
Striated/smooth ≠ discrete/continuous: both modes use the same rational arithmetic. The distinction lies in the source of the temporal structure (external grid vs. object properties), not in the mathematical domain.
_tempo() complicates the PolyMake() algorithm (see B13) because durations are no longer known in advance — they depend on instructions encountered during traversal.
The coexistence of the two approaches reflects a fundamental tension in computer music: time as structure (functional paradigm) vs. time as parameter (imperative paradigm).

Glossary

Ālāp: A slow introduction to a raga in Indian music, without a fixed pulse, where the musician gradually explores the notes of the mode.
Phase Diagram: BP3’s internal data structure (Maxconc × Maxevent grid) that represents the temporal placement of all events after polymetric expansion.
Kpress: Compression factor for the phase diagram in PolyMake(). Reduces temporal resolution when the grid exceeds memory limits.
Prod: LCM (least common multiple) of all duration ratios in a piece. Determines the resolution of the phase diagram’s integer grid.
Smooth time: BP3’s temporal mode (_smooth) where durations are intrinsic properties of objects, without reference to a pulse. Implements Boulez’s “smooth time.”
Smooth time: Boulez’s concept (1963) referring to a temporal flow without regular metric markers. A textile metaphor (without striations), not a mathematical property (continuity).
Striated time: Boulez’s concept (1963) referring to a temporal flow divided by regular markers (pulse, measure). BP3’s default mode (_striated).
Symbolic time: BP3’s representation of time as rational fractions (Q), independent of physical milliseconds.
Time pattern: In BP3, a symbol (t1, t2…) defining a relative duration in smooth time. In striated mode, time patterns have zero duration.
_tempo(): A special BP3 function (T43 in the C code) that modifies the local tempo. Changes the speed/scaling ratio in the polymetric expansion algorithm.

Prerequisites: B5, B9
Reading time: ~15 min
Tags: #smooth-time #tempo #BP3 #Boulez #ālāp #musical-time #algorithmic-composition #quantization #time-patterns