url('https://fonts.googleapis.com/css2?family=Raleway:ital,wght@0,100..900;1,100..900&family=Source+Serif+4:ital,opsz,wght@0,8..60,200..900;1,8..60,200..900&display=swap');

(min-width: 768px) {
  .article.article-md h2 {
    font-size: 24px;
  }
}

(min-width: 1024px) {
  .article.article-md h2 {
    font-size: 28px;
  }
    .heading-button {
    width: 50px;
    height: 50px;
  }
  .heading-button-arrow {
    font-size: 28px;
    padding: 12px 8px
  }
}

(max-width: 768px) {
  [data-root-node="true"] {
    --margin-left: 0px !important;
    --margin-right: 0px !important;
  }
  .contained { 
    padding: 0px 16px;
  }

  [data-tid="h"] {
    margin-left: var(--margin-left);
    margin-right: var(--margin-right);
  }
  .auto-column-container {
    column-count: 1;
  }
  .pullquote, .pullquote.left, .pullquote.right{
    float: none;
    width: 100%;
    text-align: center;
    margin-left: 0;
    margin-right: 0;
  }

  .footer-content { 
    grid-template-columns: repeat(3, 1fr);
  }

  .footer-about {
    grid-column: 1 / span 3;
  }
}

Answer Set Programming reveals the elegant logical relationships that underpin music, transforming abstract musical concepts into clear rules where scales, chords, and harmonies naturally emerge.

We might tap our fingers on the desk or hum a tune, but few of us know the beautiful, intricate relationships that underpin it all. Answer Set Programming (ASP) gives us a powerful lens to peek behind music's curtain, letting us express complex musical concepts through elegant logical rules.

What makes this journey exciting is how ASP transforms abstract musical concepts into crystal-clear logical relationships. Instead of drowning in complex music theory, we'll build an elegant system that reveals how scales, chords, and harmonies naturally emerge from simple rules. By the end, you'll see music through new eyes — not just as sounds to be played, but as a fascinating puzzle of interconnected patterns waiting to be discovered. Roll up your sleeves — we're about to turn musical intuition into logical beauty!

natural_note(a ; b ; c ; d ; e ; f ; g) .

This sequence of 7 notes is repeated creating the basic unit of an 

 (where the first note is repeated). An octave is divided into 12 equal parts called 

. The interval between each of these parts is called a 

 it (notated with a "♯") and lowering a note by a half-step 

note(a, sharp, a♯) .
note(a, flat,  a♭) .
note(b, sharp, b♯) .
note(b, flat,  b♭) .
note(c, sharp, c♯) .
note(c, flat,  c♭) .
note(d, sharp, d♯) .
note(d, flat,  d♭) .
note(e, sharp, e♯) .
note(e, flat,  e♭) .
note(f, sharp, f♯) .
note(f, flat,  f♭) .
note(g, sharp, g♯) .
note(g, flat,  g♭) .
note(N, natural, N) ← natural_note(N) .

There are 7 natural notes, the octave is divided into 12 equal parts, and there are 21 possible ways to represent notes (7 natural, 7 sharp and 7 flat). That's a whole lot of things that don't add up! (And we didn't include double sharps "𝄪" or double flats "𝄫" yet!) The way that all of this gets ironed out is that many of the notes are 

 equivalents — they're "spelled" differently but sound the same. (The 

of this is left to the reader to discover!)

For convenience, the 21 possible "spellings" are:

To establish relationships between notes, we'll define a mapping of 

. This mapping serves two purposes: it provides an ordering of notes and identifies which notes are 

 equivalents (different spellings of the same pitch). The specific ordering shown below reflects standard musical notation and practice.

halfstep((b♯;c ), (c♯;d♭)) .
halfstep((c♯;d♭), d) .
halfstep(d,       (d♯;e♭)) .
halfstep((d♯;e♭), (e ;f♭)) .
halfstep((e ;f♭), (e♯;f )) .
halfstep((e♯;f ), (f♯;g♭)) .
halfstep((f♯;g♭), g) .
halfstep(g,       (g♯;a♭)) .
halfstep((g♯;a♭), a) .
halfstep(a,       (a♯;b♭)) .
halfstep((a♯;b♭), (b ;c♭)) .
halfstep((b ;c♭), (b♯;c )) .

 between the same note is zero. This is the anchor for a recursive relation that defines the number of steps between any two notes (within an octave) both ascending and descending

interval(N, N, 0) ← note(N) .

interval(N1, N3, S+1) ←
    interval(N1, N2, S), halfstep(N2, N3),
    note(N1), note(N2), note(N3),
    S <  12 .
interval(N1, N3, S-1) ←
    interval(N1, N2, S); halfstep(N3, N2),
    note(N1), note(N2), note(N3),
    S > -12 .

We can also specify intervals with a number and a 

interval(0,  (perfect_unison ; diminished_second)) .
interval(1,  (minor_second ; augmented_unison)) .
interval(2,  (major_second ; diminished_third)) .
interval(3,  (minor_third ; augmented_second)) .
interval(4,  (major_third ; diminished_fourth)) .
interval(5,  (perfect_fourth ; augmented_third)) .
interval(6,  (tritone ; diminished_fifth ; augmented_fourth)) .
interval(7,  (perfect_fifth ; diminished_sixth)) .
interval(8,  (minor_sixth ; augmented_fifth)) .
interval(9,  (major_sixth ; diminished_seventh)) .
interval(10, (minor_seventh ; augmented_sixth)) .
interval(11, (major_seventh ; diminished_octave)) .
interval(12, (perfect_octave ; augmented_seventh)) .

 key that shares the same key signature. The relative minor is found by moving down three half-steps (or up six half-steps) from the major key's tonic. For example, 

, and they share the same key signature (no sharps or flats).

This relationship creates natural pairs of scales that are closely related but have different tonal centers and emotional qualities. The ASP code defines this relationship by finding the note that is a major sixth above the minor key (or equivalently, a minor third below the major key).

: This approach of using intervals to define relationships is particularly elegant because it leverages the existing interval logic rather than hardcoding the relationships. It also naturally handles enharmonic equivalents.

relative_minor(Major, Minor) ←
    interval(S, major_sixth), interval(Major, Minor, S), 
    note(Major), note(Minor) .

The spelling of a scale includes each letter of the natural notes. For example, the 

since the latter does not contain the letters 

. There is such a unique spelling for each tonic. To make this spelling easy, the following auxiliary predicate is defined and enumerates all of the possible combinations:

alphabet(1,c) . alphabet(2,d) . alphabet(3,e) . alphabet(4,f) . 
alphabet(5,g) . alphabet(6,a) . alphabet(7,b) .

alphabet(R, D, L) ← D = 1, note(L, _, R) .
alphabet(R, D+1, L2) ←
    alphabet(R, D, L1),
    alphabet(N1, L1), alphabet(N2, L2),
    N2 = N1\7 + 1, D < 7 .

Scales can be computed in a number of ways. The most common is to use the intervals defined for each 

). We are going to use the fact that starting from a 

 above the tonic, one can take 6 successive 

 to determine all notes of a scale. For example for a 

%* class scale(Root, Mode, Degree, Index, Note) . *%
scale(R, M, D, I, N) ←
    M = major, D = 4, I = 1,
    interval(S, perfect_fourth), interval(R, N, S),
    note(L, _, N), alphabet(R, D, L) .
scale(R, M, D2, I+1, N2) ←
    scale(R, M, D1, I, N1), interval(S, perfect_fifth), interval(N1, N2, S),
    note(L, _, N2), alphabet(R, D2, L),
    D2 = (D1 + 3)\7 + 1, I < 7 .

 scale we need to introduce double sharp (𝄪) or double flat (𝄫) accidentals to maintain proper note spelling using each letter exactly once. Double sharps raise a note by two half-steps while double flats lower a note by two half-steps. Just as with regular accidentals, we need to define these new note possibilities:

note(a, dsharp, a𝄪) .
note(a, dflat,  a𝄫) .
note(b, dsharp, b𝄪) .
note(b, dflat,  b𝄫) .
note(c, dsharp, c𝄪) .
note(c, dflat,  c𝄫) .
note(d, dsharp, d𝄪) .
note(d, dflat,  d𝄫) .
note(e, dsharp, e𝄪) .
note(e, dflat,  e𝄫) .
note(f, dsharp, f𝄪) .
note(f, dflat,  f𝄫) .
note(g, dsharp, g𝄪) .
note(g, dflat,  g𝄫) .

With the new notes defined, we need to update our 

 relationships to include these double accidentals. The relationships become more complex as each pitch can now potentially be spelled in up to 4 different ways. For example, the note we previously knew as 

 (double flat) depending on the musical context. The complete set of enharmonic relationships is:

halfstep((b♯;c ;d𝄫), (b𝄪;c♯;d♭)) .
halfstep((b𝄪;c♯;d♭), (c𝄪;d ;e𝄫)) .
halfstep((c𝄪;d ;e𝄫), (e♭;d♯;f𝄫)) .
halfstep((e♭;d♯;f𝄫), (d𝄪;e ;f♭)) .
halfstep((d𝄪;e ;f♭), (e♯;f ;g𝄫)) .
halfstep((e♯;f ;g𝄫), (e𝄪;f♯;g♭)) .
halfstep((e𝄪;f♯;g♭), (f𝄪;g ;a𝄫)) .
halfstep((f𝄪;g ;a𝄫), (g♯;a♭   )) .
halfstep((g♯;a♭   ), (g𝄪;a ;b𝄫)) .
halfstep((g𝄪;a ;b𝄫), (b♭;a♯;c𝄫)) .
halfstep((b♭;a♯;c𝄫), (a𝄪;b ;c♭)) .
halfstep((a𝄪;b ;c♭), (b♯;c ;d𝄫)) .

 relationships we defined earlier. ASP will handle these redundant facts appropriately.

Minor scales can be derived from their relative major scales, taking advantage of the relationship we defined earlier. The natural minor scale (also called the 

) uses the same notes as its relative major scale but starts from a different tonic — specifically the 6th degree of the major scale.

Rather than define the intervals directly (which would be 

 relationship and the major scale construction. Since we know that:

we can map the degrees using the formula 

 is the desired minor scale degree. This creates a mathematical relationship between the degrees that preserves the proper interval structure while maintaining correct note spelling:

scale(R, minor, D, I, N) ←
    relative_minor(MajorRoot, R),
    MajorD = ((D + 4)\7) + 1, D = 1..7, 
    scale(MajorRoot, major, MajorD, I, N),
    note(L, _, N), alphabet(R, D, L) .

 of the scale. Since we have already defined 

) we can define the tetrads in a natural way. For example, a 

tetrad(major,      major_third, perfect_fifth,    major_seventh) .
tetrad(minor,      minor_third, perfect_fifth,    minor_seventh) .
tetrad(diminished, minor_third, diminished_fifth, diminished_seventh) .
tetrad(augmented,  major_third, augmented_fifth,  minor_seventh) .

These can be converted into step sizes for convenience:

tetrad_step(M, S1, S2, S3) ←
  tetrad(M, I1, I2, I3),
  interval(S1, I1), interval(S2, I2), interval(S3, I3) .

 chords for each key as a relation between the 

chord(Root, Mode, Root, Third, Fifth, Seventh) ←
    tetrad_step(Mode, S1, S2, S3),
    interval(Root, Third, S1),
    interval(Root, Fifth, S2), 
    interval(Root, Seventh, S3),
    note(L1, _, Root),    alphabet(Root, 1, L1),
    note(L2, _, Third),   alphabet(Root, 3, L2),
    note(L3, _, Fifth),   alphabet(Root, 5, L3),
    note(L4, _, Seventh), alphabet(Root, 7, L4) .

inversion(R, M, root,   R,  N1, N2, R ) ← chord(R, M, R, N1, N2, _) .
inversion(R, M, first,  N1, N2, R,  N1) ← chord(R, M, R, N1, N2, _) .
inversion(R, M, second, N2, R,  N1, N2) ← chord(R, M, R, N1, N2, _) .

inversion(R, M, root,   R,  N1, N2, N3) ← chord(R, M, R, N1, N2, N3) .
inversion(R, M, first,  N1, N2, N3, R ) ← chord(R, M, R, N1, N2, N3) .
inversion(R, M, second, N2, N3, R,  N1) ← chord(R, M, R, N1, N2, N3) .
inversion(R, M, third,  N3, R,  N1, N2) ← chord(R, M, R, N1, N2, N3) .

voicing/4
1	alto	g	67
1	bass	g	43
1	soprano	e	76
1	tenor	e	64
2	alto	c	60
2	bass	a	45
2	soprano	a	81
2	tenor	a	57
3	alto	d	62
3	bass	d	50
3	soprano	d	74
3	tenor	b	59
4	alto	e	64
4	bass	g	43
4	soprano	g	79
4	tenor	g	55

voicing/4
1	alto	g	67
1	bass	c	60
1	soprano	c	72
1	tenor	e	64
2	alto	a	69
2	bass	c	48
2	soprano	f	77
2	tenor	c	60
3	alto	b	59
3	bass	b	47
3	soprano	g	79
3	tenor	d	50
4	alto	g	55
4	bass	c	48
4	soprano	g	79
4	tenor	e	52

voicing/4
1	alto	g	67
1	bass	c	48
1	soprano	c	72
1	tenor	g	55
2	alto	a	69
2	bass	f	53
2	soprano	a	81
2	tenor	f	65
3	alto	g	67
3	bass	g	55
3	soprano	b	71
3	tenor	b	59
4	alto	g	67
4	bass	g	55
4	soprano	g	79
4	tenor	c	60

voicing/4
1	alto	g	67
1	bass	e	40
1	soprano	g	79
1	tenor	g	55
2	alto	c	60
2	bass	f	41
2	soprano	a	81
2	tenor	f	53
3	alto	g	67
3	bass	d	50
3	soprano	d	74
3	tenor	b	59
4	alto	g	67
4	bass	g	55
4	soprano	e	76
4	tenor	c	60

voicing/4
1	alto	g	67
1	bass	g	43
1	soprano	g	79
1	tenor	e	52
2	alto	c	60
2	bass	f	41
2	soprano	a	81
2	tenor	f	53
3	alto	g	67
3	bass	g	55
3	soprano	g	79
3	tenor	d	62
4	alto	c	72
4	bass	g	55
4	soprano	g	79
4	tenor	c	60

scale_alphabet/2
1	e
2	f
3	g
4	a
5	b
6	c
7	d

scale/2
1	e♭
2	f
3	g
4	a♭
5	b♭
6	c
7	d

scale/2
1	a♯
2	b♯
4	d♯
5	e♯

scale/2
1	a♯
2	b♯
3	c𝄪
4	d♯
5	e♯
6	f𝄪
7	g𝄪

Music in ASP

Music in Logic

Basic Notes

Intervals

Unit Tests

Interval with Number and Quality

Unit Tests

Relative Minor

Unit Tests

Scales

Unit Tests

Major Scales

Unit Tests

Double Accidentals

Unit Test

Minor Scales

Unit Tests

Tetrads (Sevenths)

Unit Test

Chord

Unit Tests

Inversion

Unit Tests

Roman Numeral Analysis

Unit Tests

Voice Leading

Voices and Ranges

Unit Test

Pitches

Unit Tests

Progressions

Unit Tests

Chord Tones

Unit Tests

Voicing a Chord

Voice Ordering

Voice Movement

The Forbidden Parallels

Smooth Voice Leading

Common Tones

Unit Test

Doubling Preferences

The Moment of Truth

Making It Sing

The Unfinished Symphony

Appendix

Resources

More from Blueprints in Surface Tension

Worlds within Worlds: The Hidden Mechanics

Firestore Queries

Join us on Discord

About Us

Info

Legal

Social