Francisco's musical notebook

This is a personal note of the musical ideas that were used in the composition of my Fuga I (all rights reserved, © 2020).

In the composition of this fugue in D minor, the main idea was to use the B-A-C-H motif within the counterpoint rules of the Baroque period—in particular in Bach's time. This means:

• avoid any parallel fifths/octaves and avoid direct fifths/octaves,
  
• avoid dissonances on strong/accented beats unless it is an essential dissonance
  
• resolve the melodies correctly (vertically and horizontally), e.g. the \(^{6}_{4}\) chords (2nd inversion triads) and the \(^{2}\) chords (3rd inversion seventh chords),
  

among other general rules.

The ideas that were used as guiding principles this fugue were as follows:

• Use and explore extensively the B-A-C-H motif and try to render this motif as melodious as possible
  
• Have a well-thought and well-built structure
  
• Employ the double/triple (invertible) counterpoint as much as possible.
  

The score can be found below, and the fugue can be played here:

The structure diagram is shown in Figure 1. which shows schematically the location of the subject, countersubjects, episodes and the invertible counterpoints (inv. c.) amongst other indications. The scores with these indications can then be found in Subsection 3.2. The structure of the fugue with entries and episodes are shown on the first score. The highlighted subject,
countersubjects and the inverted counterpoint are detailed on the second score.

We now analyse the fugue with music21 (v6.7 in this appendix), a python package developed by MIT for computer-aided musicology.

There is evidence that Bach's music could be fractal, in the sense that it can exhibit pitch, interval or structural-related scaling laws^{1, 2}. A theoretical physicist's perspective of this would be the concept of universality in statistical mechanics at critical points of a system.

Here, we investigate the possibility of having an interval-related scaling law in the Fuga I. In the musical sense, the structure-related scaling might be understood easily when we think of the augmentation and the diminution of the subject, for instance. The indication that the distribution of the interval counts is fractal, however, is a bit more puzzling. This likely stems from the fact that the stepwise motion is favoured as opposed to skips and leaps.

Mathematically, with the interval (semitone) given by \(i\) and its count given by \(N\) this equates to saying that

where we consider the "size" of the interval by the function \(2^{i/12}\) to account for the fact that its frequency is logarithmic. The \(d_{f}\) denotes the fractal dimension, and the minus sign in the first equation is a matter of choice – we consider the pitch period instead of frequency, and this only changes the sign of \(d_{f}\) that we obtain at the end. Ultimately this is related to the following statement: let \(P(\varepsilon_i)\) be the probability density of elements of size \(\varepsilon_i\) with \(\sum\limits_{i=1}^{n} P(\varepsilon_i) = 1\) in a set of \(n\) elements. If there is a power-law distribution, then there is a scaling factor \(\mu = \frac{\varepsilon_i}{\varepsilon_{i+1}}\) such that \(P(\varepsilon_{i+1}) = \mu^{d_{f}} P(\varepsilon_{i})\)².

Let us first count the number of existing intervals per voice:

from music21 import *
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
from collections import Counter

# Import Fuga I
path = './Fuga I analysis with music21.musicxml'
fugue = converter.parse(path)

# Get notes & intervals per voice (1, 2, 3) and then merge
# all of them (hence length = 4).
# Voice 1: soprano (last entry) / Voice 2: tenor/alto (first entry) /
# Voice 3: bass (second entry) / Voice 4: all
notes = []
for i in range(len(fugue.parts)):
    pitchesPerVoice = fugue.parts[i].flat.notes
    notes.append([n.pitch.ps for n in pitchesPerVoice])
notes.append([note for voice in notes for note in voice])

intervals = []
for voiceNotes in notes:
    intervalsPerVoice = []
    for j in range(len(list(voiceNotes))-1):
        intervalsPerVoice.append(abs(voiceNotes[j+1]-voiceNotes[j]))
    intervals.append(intervalsPerVoice)

# Show existing intervals in the Fuga I
analysis.discrete.MelodicIntervalDiversity().countMelodicIntervals(fugue.parts)

{'P4': [<music21.interval.Interval P4>, 48],
'm2': [<music21.interval.Interval m2>, 190],
'm3': [<music21.interval.Interval m3>, 56],
'M2': [<music21.interval.Interval M2>, 264],
'd4': [<music21.interval.Interval d4>, 3],
'm6': [<music21.interval.Interval m6>, 11],
'A1': [<music21.interval.Interval A1>, 14],
'M6': [<music21.interval.Interval M6>, 15],
'M3': [<music21.interval.Interval M3>, 16],
'A2': [<music21.interval.Interval A2>, 3],
'P11': [<music21.interval.Interval P11>, 1],
'P5': [<music21.interval.Interval P5>, 8],
'm14': [<music21.interval.Interval m14>, 1],
'P8': [<music21.interval.Interval P8>, 5],
'M10': [<music21.interval.Interval M10>, 1],
'd5': [<music21.interval.Interval d5>, 1]}

Now count intervals for each voice:

intervalCounts = []
sortedIntervalCounts = []
for i in range(len(intervals)):
    intervalCount = Counter(intervals[i])
    sortedIntervalCount = sorted(intervalCount.items())

    intervalCounts.append(intervalCount)
    sortedIntervalCounts.append(sortedIntervalCount)

    print("Voice {}: {}".format(i+1, sortedIntervalCounts[i]))

Voice 1: [(0.0, 5), (1.0, 59), (2.0, 86), (3.0, 15), (4.0, 6), (5.0, 16), (8.0, 3), (9.0, 5), (17.0, 1)]
Voice 2: [(0.0, 9), (1.0, 76), (2.0, 86), (3.0, 26), (4.0, 8), (5.0, 19), (7.0, 3), (8.0, 3), (9.0, 6), (12.0, 1), (22.0, 1)]
Voice 3: [(0.0, 4), (1.0, 69), (2.0, 92), (3.0, 18), (4.0, 5), (5.0, 13), (6.0, 1), (7.0, 5), (8.0, 5), (9.0, 4), (12.0, 4), (16.0, 1)]
Voice 4: [(0.0, 18), (1.0, 204), (2.0, 264), (3.0, 59), (4.0, 19), (5.0, 48), (6.0, 1), (7.0, 8), (8.0, 11), (9.0, 16), (12.0, 6), (16.0, 1), (17.0, 1), (22.0, 1)]

Let us now choose the bin size (as well as how to treat the intervals) of each voice by considering the melodies. In other words, let us take into account the melodic jump between measures 26 and 28 for the analysis of the soprano voice (voice 1), i.e., we omit the intervals larger than 9 semitones. For the tenor/alto voice (voice 2), the jump in measure 25 and the octave jump in 27 will be considered. Lastly, the bass voice (voice 3) will exclude the jump between measures 12 and 13:

# Voice 1
# Jump in measures 26-28
bins1 = [0, 3, 6, 9]
foldedIntervals1 = [i for i in intervals[0] if i <= 9]    # omitted after 9

# Voice 2
# Jump in measure 25 & octave jump in 27
bins2 = [0, 3, 6, 9]
foldedIntervals2 = [i for i in intervals[1] if i <= 9]    # omitted after 9

# Voice 3 
# Jump in measures 12-13
bins3 = [0, 3, 6, 9, 12]
foldedIntervals3 = [i for i in intervals[2] if i <= 12]    # Omitted after 12

# All the voices
bins4 = [0, 5, 10, 16]
foldedIntervals4 = [i for i in intervals[3] if i <= 16]    # Omitted after 16

The bin \(0-3\), for instance, includes the interval 0 but not the interval 3. This is true for all bins except for the last bins that include the supremum. The last bins can also be stretched to accommodate the extremal intervals that are used sparingly in music.

As an example, when looking at all the melodies together after our choice of bin size and interval treatment, the following intervals remain:

bins = [bins1, bins2, bins3, bins4]
foldedIntervals = [foldedIntervals1, foldedIntervals2, foldedIntervals3, foldedIntervals4]

newIntervalCounts = [np.histogram(foldedIntervals[i], bins=bins[i])[0] for i in range(4)]

newFoundIntervals = []
for i in range(4):
    newIntervals = []
    for j in range(len(bins[i])-1):
        newIntervals.append((bins[i][j] + bins[i][j+1])/2)
    newFoundIntervals.append(newIntervals)

sorted(Counter(foldedIntervals[3]).items())

[(0.0, 18),
(1.0, 204),
(2.0, 264),
(3.0, 59),
(4.0, 19),
(5.0, 48),
(6.0, 1),
(7.0, 8),
(8.0, 11),
(9.0, 16),
(12.0, 6),
(16.0, 1)]

Finally, the final fractal dimension of the Fuga I is shown here:

figIndex = 3
xOrig = np.array(newFoundIntervals[figIndex]).reshape((-1, 1))
f = lambda k: 2 ** (k/12)
x = np.log(f(xOrig))
y = np.log(np.array(newIntervalCounts[figIndex]))

linearRegression = LinearRegression()
model = linearRegression.fit(x, y)
y_pred = linearRegression.predict(x)
r_sq = model.score(x, y)

# Plot
fig, (ax1) = plt.subplots(nrows=1, ncols=1, figsize = (6,4))

ax1.scatter(x, y, color="black")
ax1.plot(x, y_pred, color="blue", linewidth=3, \
         label=r'$\log(N) = C - d_{f}\, \log(2^{i/12})$')

ax1.set_xlabel(r'$\log(2^{i/12})$', fontsize=10)
ax1.set_ylabel(r'$\log(N)$', fontsize=10)

ax1.set_title('All the voices', fontsize=12)
ax1.text(0.9, 0.6, \
         r'$d_{f} =$' + str(round(-linearRegression.coef_[0], 3)) + '\n \n' + r'$R^{2} =$' + f'{r_sq:.3f}', \
         horizontalalignment='center', verticalalignment='center', fontsize=10, transform=ax1.transAxes)
ax1.text(0.03, 0.06, 'Bins: ' + f'{bins[figIndex]}', \
         horizontalalignment='left', fontsize=6, transform=ax1.transAxes)
ax1.legend(numpoints=1, loc=1, fontsize=7)

plt.show()

We now show the anaylsis for separate voices as well, where the most coherent bin size and the interval treatment (with respect to the music structure and the musical ideas) have been selected, as mentioned above:

f = lambda k: 2 ** (k/12)

xOrig = [np.array(newFoundIntervals[i]).reshape((-1, 1)) for i in range(4)]
x = [np.log(f(xOrig[i])) for i in range(4)]
y = [np.log(np.array(newIntervalCounts[i])) for i in range(4)]

linearRegression = [LinearRegression() for i in range(4)]
model = [linearRegression[i].fit(x[i], y[i]) for i in range(4)]
y_pred = [linearRegression[i].predict(x[i]) for i in range(4)]
r_sq = [model[i].score(x[i], y[i]) for i in range(4)]

# Plot
#fig, axs = plt.subplots(nrows=2, ncols=2, figsize = (6,4), tight_layout = True)
fig, axs = plt.subplots(nrows=2, ncols=2, figsize = (9,6))
fig.subplots_adjust(hspace = .6, wspace=.3)
axs = axs.ravel()

titles = ['Voice 1', 'Voice 2', 'Voice 3', 'All the voices']

for i in range(4):
    axs[i].scatter(x[i], y[i], color="black")
    axs[i].plot(x[i], y_pred[i], color="blue", linewidth=3, \
                label=r'$\log(N) = C - d_{f}\, \log(2^{i/12})$')
    axs[i].set_xlabel(r'$\log(2^{i/12})$', fontsize=10)
    axs[i].set_ylabel(r'$\log(N)$', fontsize=10)
    axs[i].set_title(f'{titles[i]}', fontsize=12)
    axs[i].text(0.85, 0.62, \
                r'$d_{f} =$' + str(round(-linearRegression[i].coef_[0], 3)) + '\n \n' + r'$R^{2} =$' + str(round(r_sq[i], 3)), \
                horizontalalignment='center', verticalalignment='center', fontsize=10, transform=axs[i].transAxes)
    axs[i].text(0.03, 0.06, 'Bins: ' + f'{bins[i]}', \
                horizontalalignment='left', fontsize=6, transform=axs[i].transAxes)
    axs[i].legend(numpoints=1, loc=1, fontsize=7)

plt.show()

The fit using three points only could make us doubt that the interval distribution is really fractal. But it should be reminded that such a fractal law in music should only arise after some coarse-graining at a larger scale. And since that an octave is divided in 12 semitones only and that the musically coherent intervals are quite limited, finishing with three points only at the end of the binning does not seem unreasonable. And a linear fit of three points is by no means a trivial guarantee :).

It should also be noted, however, that the dimension and the \(R^2\) are all quite sensitive to the bin size and the way we treat the intervals. For completeness, here are some of the results with different configurations:

The selected version for the analysis with all the voices (red line) assumes that a jump of up to a a tenth (16 semitones) is reasonable but that jumps greater than that are to evoke a very special and out-of-the-ordinary effect.

Back to the sitemap³