Music Theory Tips for Programmers

Key Takeaways:

Western tuning follows a geometric progression: A4 is 440 Hz and each of the 12 semitones multiplies frequency by the twelfth root of two.
A note corresponds to a position on a 12-slot wheel, an interval counts the steps between notes, and a chord is a fixed pattern of step sizes stacked from the root.
Libraries like musthe and music21 represent these rules as data structures, so you rarely need to implement the math yourself.
Scale harmonization and reverse key detection are two features that turn a note model into a practical composition tool.

Why Music Theory Maps to Code

Western music theory relies on integer arithmetic, which explains why it fits naturally into a program. Middle A, labeled A4, is tuned to 440 Hz, and each of the 12 semitones in an octave multiplies that frequency by the twelfth root of two. A note corresponds to a position on a 12-slot wheel that repeats every octave, an interval counts the number of steps around that wheel, and a chord is a fixed set of step sizes stacked on top of a root note.

Scales, Harmonization, and Key Detection

With this framework, a scale is an ordered list of notes, and a chord progression moves through those lists in sequence. Elements of music theory that often confuse beginners (key signatures, accidentals, and chord qualities) are essentially lookup tables. The Python library musthe describes itself as “Music theory implemented in Python. Notes, scales and chords.” Its internal code makes this mapping clear and is worth examining even if you don’t use the package. This approach of encoding domain rules as data structures is similar to how a home-built cloud server can be configured through simple files instead of custom scripts.

This guide builds a model from the ground up, then shows how these abstractions appear in established tools. Everything below runs in a plain Python interpreter with no dependencies beyond the standard library, except where a specific library is mentioned.

Pitch Classes and Frequency

Every note can be represented by two numbers: a pitch class from 0 to 11, and an octave. In musthe’s source code, a note stores a letter, an accidental, and an octave, then calculates an integer “number” equal to the letter’s pitch offset plus the octave times 12. This integer represents the note’s position on the wheel and matches MIDI numbering, except that C0 starts at 0.

The frequency of any note can be calculated from that integer. musthe computes it as 440.0 * pow(2, (number - Note('A4').number) / 12.0), which directly applies the twelfth-root-of-two rule. You can reproduce the core calculation in a few lines:

def midi_from_pitch_class(pc, octave):
 return octave * 12 + pc # C4 = 48, A4 = 69

def hz(midi):
 return 440.0 * 2 ** ((midi - 69) / 12.0)

# A4 is pitch class 9, octave 4
a4 = midi_from_pitch_class(9, 4)
print(a4, round(hz(a4), 2))
# 69 440.0

# C4 should be 261.63 Hz
print(round(hz(midi_from_pitch_class(0, 4)), 2))
# 261.63

Pitch class 9 corresponds to the note A, so A4 is MIDI 69 and 440 Hz by definition, and C4 calculates to 261.63 Hz. These two functions cover every key on a piano. The “note name” issue that looks complicated (G-sharp versus A-flat) is actually about labeling the same integer differently. musthe manages this by keeping the letter separate from the accidental: G#4 and Ab4 have the same pitch-class number but different letters, which is important for correctly spelling chords within a key.

Intervals, Chords, and Recipes

An interval is simply a semitone count with a name. musthe stores a table mapping each interval to its semitone value: minor second (m2) is 1, major second (M2) is 2, minor third (m3) is 3, major third (M3) is 4, perfect fifth (P5) is 7, and minor seventh (m7) is 10. The names also include a “number,” the diatonic count of letters spanned, which lets the library recognize that C to E is a third even though it spans four semitones. Compound intervals larger than an octave are split into a perfect octave plus a simple interval, and every interval has an inverse complement.

Music theory structures mapped to code structures

A chord is a pattern of intervals applied to a root note. musthe’s chord table defines a major chord as [P1, M3, P5] and a minor chord as [P1, m3, P5], where P1 is a unison. The difference between a major and minor triad is one semitone in the middle note. Here is the same concept written manually:

SEMITONES = {"P1": 0, "m2": 1, "M2": 2, "m3": 3, "M3": 4,
 "P5": 7, "m7": 10}

CHORD_RECIPES = {
 "major": ["P1", "M3", "P5"],
 "minor": ["P1", "m3", "P5"],
}

def chord(root_midi, quality):
 return [root_midi + SEMITONES[i] for i in CHORD_RECIPES[quality]]

print(chord(69, "major")) # A major: A, C#, E
# [69, 73, 76]
print(chord(69, "minor")) # A minor: A, C, E
# [69, 72, 76]

Seventh and extended chords use the same approach with additional intervals. A dominant seventh adds m7, a major seventh adds M7, and so on. This shows that chord quality is a data problem rather than a musical one: once the recipes are in a table, generating any chord from any root is a simple list comprehension.

Scales, Harmonization, and Key Detection

A scale is an ordered list of notes built from a tonic and a pattern of steps. The major scale follows the semitone pattern 2-2-1-2-2-2-1, which is why the B major scale in musthe resolves to B, C#, D#, E, F#, G#, A#. The library lets you test membership directly: Note('D#3') in scale returns True, and Chord('C#m') in scale checks whether every note of the chord belongs to the scale.

Two operations make this model useful for composition. The first is harmonization. Given a scale, musthe’s harmonize() method returns, for every note in the scale, the set of diatonic and dominant-seventh chords you can build on that note. This produces the familiar I-ii-iii-IV-V-vi-vii° pattern: in C major it generates a C major chord, D minor, E minor, F major, G major, A minor, and B diminished.

The second operation is reverse key detection. Given a list of chords, you can find which scales include all of them:

# In musthe: find every scale that contains these three chords
# chords = [Chord('Cm'), Chord('Fm7'), Chord('Gm')]
# for scale in Scale.all():
# if chords in scale:
# print(scale)
# C natural_minor
# Eb major

The Cm, Fm7, Gm progression corresponds to C natural minor and E-flat major, which are relative keys sharing the same notes. This directly encodes a music-theory fact: a minor key and its relative major contain identical pitch classes. Searching scales with a chord list provides a one-line way to determine the key of a song, which is the same task Music Information Retrieval systems like audio key detection perform using signal processing.

Libraries and Where They Diverge

Two Python libraries dominate this area, serving different purposes. musthe is small and easy to read, with about 357 stars and 41 forks on GitHub, and its core logic contained in a single 597-line file. It functions as a teaching tool and a lightweight dependency for generating notes, scales, and chords, and it can optionally render melodies to LilyPond notation. Its last commit was in July 2024, so it is mostly in maintenance mode.

music21 is a more comprehensive toolkit for computer-aided musical analysis and computational musicology, with roughly 2,573 stars and 453 forks. It is released under the BSD 3-clause license and actively maintained (its repository was updated within days of this writing). It reads and writes MusicXML, MIDI, and other formats, and runs on Python 3.12 and later. While musthe provides note arithmetic, music21 handles full scores, streams, and analytical queries over real repertoire.

Concept	How a program represents it	musthe type
Pitch (single note)	Letter + accidentals + octave, converted to an integer offset from C0	Note
Interval	Semitone count plus diatonic number (M3 = 4, P5 = 7)	Interval
Chord	Root note plus interval recipe (minor = P1, m3, P5)	Chord
Scale	Ordered list of notes from tonic following a step pattern	Scale

The choice depends on your needs. If you are building a generative tool and want to list chords or check scale membership, musthe’s small API is quicker to learn and easier to include. If you need to parse MusicXML scores, transpose full pieces, or perform musicological analysis, music21 is the practical option, though it requires a larger dependency and more learning. The two libraries serve different levels of the same domain.

What This Means for Real Projects

The same abstractions appear in research systems, which confirms how broadly the model applies. A 2024 paper on enumerating chord progressions describes a Java algorithm applying music-theory rules that produces 3,297 valid four-chord progressions and 405,216 eight-chord progressions, divided into 1,533 major and 1,764 minor four-chord sequences. This reflects the combinatorial nature of treating chords as recipes and progressions as sequences: the search space is finite and enumerable, which makes it programmable.

Even machine learning models identify the same structure. The JamBot paper found that a chord-prediction LSTM, trained only on polyphonic music, extracted the circle of fifths from its learned chord embeddings without explicit instruction. The circle of fifths is a 12-step cycle where each chord root is a perfect fifth (7 semitones) above the previous one, forming the basis of tonal harmony. That a neural network rediscovered a structure a programmer can express in three lines of modular arithmetic indicates that the integer model accurately reflects the domain.

For developers, this means you should use lookup tables instead of machine learning when possible. Chord generation, key detection, transposition, and harmonization can all be handled by the data structures described here, running in microseconds. Learning-based methods are useful when the goal is open-ended composition with too large a search space to enumerate. For chord chart tools, practice apps, or generative sequencers, starting with musthe or music21 and a few interval recipes will cover most needs before writing any audio code.

More in-depth coverage from this blog on closely related topics:

Sources and References

Sources cited while researching and writing this article: