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 has almost made us forget the other.

Where Does This Article Fit In?

B5 showed how BP3 superposes temporal streams through polymetry. B9 showed that these streams 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 frequent confusion: the striated/smooth distinction in BP3 is not the discrete/continuous distinction of signal theory. It is both more subtle and more musical.

The Idea in One Sentence

BP3 offers three families of mechanisms to control the temporal flow: smooth time (durations intrinsic to objects), the speed operators /N and \N (integer commands), and _tempo(x/y) (rational command) — three approaches that reflect a fundamental 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… They 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 simple membership in a mathematical set. These three domains — Z, Q, R — correspond to three ontological levels of time, which perform 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 pattern occupies 7/3 of the cycle”
R (reals) Nature The time of physical phenomenon, of continuous perceptual flow Sound wave, lived duration, musician’s gesture

BP3’s choice to work in Q is a technical choice: rational arithmetic eliminates rounding errors that accumulate in floating-point calculations. When BP3 calculates polymetric ratios (7 notes in the space of 5, or 3/4 of a beat), fractions yield an exact result — not an approximation. This is exactly what Bernard Bel implements when he titles his seminal paper “Rationalizing Musical Time” [Bel2001] — rationalizing, in the sense of making rational (Q) to eliminate numerical inaccuracies.

The transition to physical time (milliseconds) is done by a simple multiplication via the metronome:

 

_mm(120)   →   1 symbolic beat = 500 physical ms

 

A do quarter note 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 arithmetically exact. It is not a “quantization” in the signal processing sense, 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 proposes an opposition between two textures of time. The image is textile: a striated fabric is crossed by regular lines (warp threads), while a smooth felt is homogeneous, without any privileged direction. (Note: Deleuze and Guattari would take up this smooth/striated distinction in A Thousand Plateaus in 1980, borrowing from Boulez — not the other way around.) Boulez transposes this image to musical time:

  • Striated time is a counted time: a regular pulsation cuts it into units (beats, measures, subdivisions). The musician navigates within this grid — placing notes on the beats. It is the time of the military march, the waltz, the metronome. The vast majority of Western music lives in striated time.
  • Smooth time is a non-counted time: no reference pulsation, no grid. Durations are not positions on a grid but qualities inherent to the sound events. It is the time of meditation, the drone, free improvisation — a flow where reference points emerge from the sound material itself rather than from an external clock.

Boulez specifies that both are limiting cases: most real music oscillates between the two, and a composer can switch from one to the other within the same work. But the conceptual distinction is sharp.

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

  • _striated (default mode): events are placed on a pulsation grid. Durations are determined by the position between two beats.
  • _smooth: the grid disappears. Durations become intrinsic properties of objects, defined by ratios 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
Pulsation 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 an engineer — it evokes continuity in the C^∞ sense. But Boulez is not talking about mathematical continuity. His “smooth time” is a time without striations: without the regular lines of a pulsation. 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 a finite resolution:

  1. 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.
  2. If the grid is too fine for memory, a compression factor Kpress reduces it.
  3. Finally, the temporal resolution (10 ms by default) sets the smallest gap between two sent MIDI events.

 

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

 

This quantization 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 (denoted t1, t2, etc.) are temporal 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 the 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 this. The line _smooth 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 of the reference duration

In rule GRAM#1[2], the polymetric expression {t1 t3 t4, C4 D4 E4 F4 - A4} means: superpose 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 on the irregular lattice created by the time patterns. This is what Bernard Bel calls, quoting Xenakis, a temporal structure (temporal structure, Xenakis 1963) — a framework of relative durations intrinsically linked to the musical syntax.

The result is a sequence of notes with irregular gaps, reflecting the natural breathing of a musical phrase rather than the rigor 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 point of view. The notes are then distributed uniformly over the pulsation grid.

It is 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 of a raga — a slow and meditative exploration of the notes of the mode, without a fixed pulsation. The musician deploys 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 grid of beats — was inapplicable.

BP3’s smooth time resolves 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 pulsation. 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 using smooth time 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 pattern, 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, going from 60 to 80 and 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 goes 88/60 times slower than the reference tempo → equivalent to playing at 60 BPM
  • t2 = 88/80: the music goes 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), so it plays at 60 BPM. Parts 2-8 use Tp2 and Tp3, transitioning to 80 and 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 blocks of Tp1 → effective tempo 60 BPM

GRAM#1[3] Part2 --> {Tp2 Tp2 Tp2 Tp2 Tp2, P2}
            -- 5 blocks of Tp2 → effective tempo 80 BPM

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

-- Each Tp is a subgrammar of 8 repetitions of the 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 stretched over this 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:

  1. Calculate the ratio 88/60
  2. Declare it as a time pattern
  3. Build an entire voice of repeated time patterns
  4. Superpose 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().

Speed Operators: /N, \N, *N, **N

Before _tempo(), BP3 already had four primitive operators to modify the speed of the stream. They are inherited from BP1/BP2 and remain available in BP3 web.

The Four Operators

Operator Syntax Effect Example
/N /3 Multiplies speed by N “Play 3 times faster”
\N \2 Divides speed by N “Play 2 times slower”
*N *4 Multiplies scaling by N Changes the temporal scale
**N **3 Divides scaling by N Inverse of the previous one

Important constraint: N must be a positive integer. One cannot write /3.5 or \2/3. This is the main limitation of these operators.

How It Works in the Code

The PolyMake() algorithm maintains two internal variables, speed and scaling. The effective tempo at any given point is their ratio speed/scaling. The four operators act on these variables:

 

/N    →    speed = firstscaling × N
\N    →    speed = firstscaling / N
*N    →    scaling = N
**N   →    scaling = 1/N

 

Speed (speed) and scale (scaling) are conceptually distinct: speed says “how many notes per unit of time”, scaling says “how many units of time in this space”. But in practice, it is their ratio that determines the tempo.

Scope

These operators are sequential: they modify the speed from the point where they appear and remain active until the next operator of the same type. In the stream do /2 ré mi \1 fa, ré and mi are played at double speed, then fa returns to normal speed.

An Example

 

_mm(120) _striated

S --> do ré /2 mi fa sol \1 la si do

 

The notes do ré are played at normal tempo (120 BPM). Then /2 doubles the speed: mi fa sol are played at 240 BPM — twice as fast. Finally \1 restores the base speed: la si do return to 120 BPM.

This is effective for simple changes. But for a ratio like 88/60 (the acceleration in Shapes in Rhythm), it cannot be expressed — 88/60 is not an integer.

And the Polymetric Ratio {N, ...}?

The N at the head of a polymetric expression {N, do ré mi} (“these 3 notes fit into N beats”) is not a tempo operator. It is a structural ratio: it defines how much space the sequence occupies, not how fast it is played. Its scope is strictly local to the group within curly braces. And unlike /N, it accepts rationals: {3/2, do ré mi} is valid.

The difference is conceptual: /2 do ré mi says “play these notes twice as fast (and everything that follows as well)”. {2, do ré mi} says “these three notes fit into 2 beats (then we return to normal)”.

The _tempo() Operator: A More Powerful Interface

The Intuition

_tempo() unifies the /N, \N, *N, and **N operators into a single command that accepts rational fractions. Instead of defining objects with intrinsic durations (smooth time) or limiting oneself to integers (/N), we insert a control instruction into the stream:

 

_tempo(3/2)    →   "from here on, play 1.5 times faster"

 

This is a change of paradigm, not just syntax:

  • In smooth time, time is a property of the object (the object is slow)
  • With /N and \N, time is an integer command (an integer factor is imposed)
  • With _tempo(), time is a rational command (any factor can be imposed)

The Syntax

_tempo(x/y) modifies the local speed by a factor of x/y. In BP3’s C code, this translates to the same mechanics as /N and *N, but in a single instruction:

 

speed = oldspeed × x
scaling = oldscaling × y

 

The effective tempo is the ratio speed/scaling. A _tempo(2/1) doubles the speed (equivalent to /2); a _tempo(1/2) divides it by two (equivalent to \2). But _tempo(88/60) is unexpressible with primitive operators — that is its entire added value.

The Five Tempo Mechanisms in Summary

Mechanism Syntax Domain Scope Nature
/N /3 Integers Sequential Speed command
\N \2 Integers Sequential Speed command
*N *4 Integers Sequential Scaling command
**N **3 Integers Sequential Scaling command
_tempo(x/y) _tempo(88/60) Rationals Sequential Unified command
{N, ...} {3/2, ...} Rationals Local (group) Structural ratio
Smooth time t1 = 3/2 Rationals Local (object) Object property

The last three rows are not “tempo operators” in the same sense as the first four. The polymetric ratio is structural (it defines a space, not a speed). Smooth time is ontological (duration is part of the object). Only /N, \N, *N, **N, and _tempo() actually modify the speed of traversal of the stream.

“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, as is
Part2 --> _tempo(80/60) P2           -- accelerates to 80
Part9 --> _tempo(88/60) P9           -- accelerates to 88

 

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

What _tempo() Costs Internally

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

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:

  1. Traverse each voice, applying any encountered _tempo()
  2. Calculate the “real” duration of each voice (which is no longer simply the number of elements)
  3. Normalize to align the voices
  4. If undetermined rests (rests of undetermined duration, denoted … 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 a 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 computer science 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 reference points 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 the time it takes.

Time as a Command (_tempo)

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

This vision is imperative: commands are inserted into the stream 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 a single 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 split echoes a broader asymmetry in BP3’s architecture (see B4): BP3 grammar excels at expressing musical structures (polymetry, hierarchy, recursion) but resorts to ad hoc control mechanisms (such as 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 ratios between time patterns, without having to specify the durations of the notes individually. And these ratios are irreducible to integers: this is precisely where 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 sound result is the same, but the grammar expresses a different intention: we no longer say “here is a lattice of durations”, we say “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 down 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 removes the pulsation 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.
  • Four primitive speed operators (/N, \N, *N, **N) modify the speed and scaling of the stream. They only accept positive integers — their legacy from BP1/BP2.
  • The _tempo(x/y) operator unifies these four operators by accepting rational fractions, allowing ratios like 88/60 that are impossible with /N alone.
  • The polymetric ratio {N, ...} is not a tempo operator: it is a structural ratio (how many beats, not how fast), with a scope local to the group.
  • 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 these approaches reflects a fundamental tension in computer music: time as a property of objects (smooth time), as an integer command (/N, \N), or as a rational command (_tempo()).

To Go Further

  • BP3 Documentation: Time patterns & smooth time — tutorial and examples
  • Example: Shapes in Rhythm — complete composition in smooth time
  • Quantization: Time resolution and quantization — Level 3 in detail
  • Boulez, P. (1963). Penser la musique aujourd’hui. Gonthier — the striated time / smooth time distinction.
  • Xenakis, I. (1963). Musiques formelles. Stock — the notion of “temporal structure” cited by Bel.
  • Bel, B. (1992). “Time-setting of sound-objects: a constraint-satisfaction approach.” — time-setting as constraint satisfaction scheduling.
  • Bel, B. (2001). “Rationalizing Musical Time: syntactic and symbolic-numeric approaches.” — complete formalization of symbolic time in BP3.
  • Prerequisite article: B5, B9
  • Next: B13

Glossary

  • /N and \N: Primitive speed operators of BP3. /N multiplies speed by N (accelerates), \N divides it by N (slows down). N must be a positive integer. Inherited from BP1/BP2. In the C code: T0 with sub-type 11 (/) or 25 (\).
  • \N and \\*N: Scaling operators of BP3. *N multiplies scaling by N, **N divides it by N. N must be a positive integer. In the C code: T0 with sub-type 21 (*) or 24 (**).
  • Ālāp: Slow introduction of a raga in Indian music, without a fixed pulsation, where the musician progressively explores the notes of the mode.
  • Phase diagram: Internal data structure of BP3 (Maxconc × Maxevent grid) representing the temporal placement of all events after polymetric expansion.
  • Kpress: Compression factor of 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 integer grid of the phase diagram.
  • Polymetric ratio: The N in {N, ...}. Defines how many beats the sequence occupies. It is not a tempo operator (no speed modification), it is a structural ratio with local scope. Accepts rationals ({3/2, ...}).
  • Scaling: Internal variable of PolyMake() which, combined with speed, determines the effective tempo (speed/scaling). Modified by *N, **N and the denominator of _tempo(x/y).
  • Smooth time: Temporal mode of BP3 (_smooth) where durations are intrinsic properties of objects, without reference to a pulsation. Implements Boulez’s “smooth time”.
  • Speed: Internal variable of PolyMake() representing the current speed of the stream. Modified by /N, \N and the numerator of _tempo(x/y).
  • Smooth time: Concept from Boulez (1963) designating a temporal flow without regular metric reference points. Textile metaphor (without striations), not a mathematical property (continuity).
  • Striated time: Concept from Boulez (1963) designating a temporal flow divided by regular reference points (pulsation, measure). Default mode of BP3 (_striated).
  • Symbolic time: Representation of time in BP3 in the form of 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(): Special function of BP3 (T43 in the C code) that modifies the local tempo by a rational factor x/y. Unifies /N (speed) and *N (scaling) into a single command: speed *= x, scaling *= y.

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

← Back to index