# Defenbaugh F to F Temperament

Source: Reblitz, Arthur A. *Piano Servicing, Tuning, and Rebuilding*, 3rd ed. Vestal Press, 2019.

The steps below are this project's own summary of the sequence, not the book's text. Read the
book for the full explanation. "Flat side" and "sharp side" say where the note being tuned sits
relative to a pure interval. In step 12 the book's G36-C40 is read as G#36-C40, the third that
follows F#34-A#38.

---

## Temperament Steps

1. Match A49 to the tuning fork.

2. Set A37 an octave below A49, a hair wider than pure: its 4th partial should sit just under the 2nd partial of A49. To confirm, play F33 against A37 (a major third) and against A49 (a major tenth). F33 only needs to be near enough to make both intervals beat. The third should beat about half a beat per second slower than the tenth. An octave stretched this little still sounds clean, and the extra room helps the rest of the octave come out even.

3. Set F33 so the major third F33-A37 beats about 7 times a second, with F33 on the flat side of pure.

4. Set D42 so the major sixth F33-D42 beats about 8 times a second, with D42 on the sharp side. Then check the fourth A37-D42: wide by 1 beat per second at most.

5. Set A#38 so the major third A#38-D42 beats about 9 times a second, with A#38 on the flat side. Then check the fourth F33-A#38: wide by 1 beat per second at most.

6. Set C#41 above A37, on the sharp side, so the third A37-C#41 beats a little slower than A#38-D42.

7. Set G#36 below C#41, on the flat side, so the fourth G#36-C#41 beats less than once a second.

8. Set C40 above G#36, on the sharp side, so the third G#36-C40 beats a little slower than A37-C#41. Then check the fifth F33-C40: narrow by about half a beat per second.

9. Set F#34 below A#38, on the flat side, so the third F#34-A#38 beats a little faster than F33-A37. Then check the fifth F#34-C#41: narrow by about half a beat per second, and a little faster than F33-C40.

10. Set D#43 above F#34, on the sharp side, so the sixth F#34-D#43 beats a little faster than F33-D42.

11. Set B39 below D#43, on the flat side, so the third B39-D#43 beats a little faster than A#38-D42. Then check the fourth F#34-B39: wide by 1 beat per second at most, and a little faster than F33-A#38.

12. Set G35 below B39, on the flat side. The third G35-B39 belongs between F#34-A#38 and G#36-C40 in speed. Then check the fourth G35-C40: wide by 1 beat per second at most, and a little faster than F#34-B39. Check the fifth G35-D42 too: narrow by about half a beat per second, and a little faster than F#34-C#41.

13. Set E44 above G35, on the sharp side, so the sixth G35-E44 beats a little faster than F#34-D#43. Then check C40-E44, B39-E44 and A37-E44: each should carry on the steady climb of the intervals of its kind just below it.

14. Set F45 above G#36, on the sharp side, so the sixth G#36-F45 beats a little faster than G35-E44. Then check C#41-F45, C40-F45 and A#38-F45 the same way, and the octave F33-F45.

## Final Test

Compare each inside third with the outside sixth around it. Start with the third G35-B39 and the sixth F33-D42: the sixth should beat at about the same speed as the third, or a touch faster. Move both up a semitone and compare again, until the sixth reaches F45. Retune any note whose interval breaks the pattern.

---

# Algorithmic Interpretation for Software Implementation

Each step in this temperament can be mapped into machine-friendly structures.
Your tuning engine needs the following:

### Required Inputs
- Fundamental frequency of each played note.
- Frequencies of detectable partials (at least up to the 6th partial, needed for minor 3rds).
- Signed beat rate between two coincident partials (see "Beat Sign Convention" below).

### Interval Partial Mapping
Each interval beats between one partial of the lower note and one partial of the upper note.
The ratio is written lower:upper.

| Interval        | Lower note partial | Upper note partial | Ratio |
|-----------------|--------------------|--------------------|-------|
| Octave (4:2)    | 4th                | 2nd                | 4:2   |
| Major 3rd       | 5th                | 4th                | 5:4   |
| Minor 3rd       | 6th                | 5th                | 6:5   |
| 4th             | 4th                | 3rd                | 4:3   |
| 5th             | 3rd                | 2nd                | 3:2   |
| Major 6th       | 5th                | 3rd                | 5:3   |
| Major 10th      | 5th                | 2nd                | 5:2   |

In equal temperament, 3rds, 6ths, 10ths and 4ths are wide, 5ths are narrow,
and octaves are pure or very slightly wide.

### Beat Sign Convention
The beat rate is signed so that the direction (wide or narrow) is never lost:

    signedBeat = f(upper note partial) - f(lower note partial)

- `signedBeat > 0`: the interval is **wide** (larger than pure).
- `signedBeat < 0`: the interval is **narrow** (smaller than pure).
- `|signedBeat|`: the beat **speed** in beats per second (bps), which is what the ear hears.

The book describes direction from the point of view of the note being tuned: in step 3,
F33 goes about 7 bps flat of A37. Lowering the bottom note or raising the top note
widens an interval, so that step means the F33-A37 major 3rd should be about 7 bps wide.

### Beat Relationship Types
Speed comparisons use `|signedBeat|`. Direction checks use the sign.

- absolute target with direction (e.g., "about 7 bps wide" → `signedBeat ≈ +7 ± tolerance`)
- noMoreThan with direction (e.g., "no more than 1 bps wide" → `0 <= signedBeat <= 1.0`)
- lessThan (e.g., "less than 1 bps flat")
- approximately with direction (e.g., "about 1/2 bps narrow" → `signedBeat ≈ -0.5 ± tolerance`)
- slightlyFasterThan reference interval (compares speeds)
- slightlySlowerThan reference interval (compares speeds)

### Example Machine Rules
"no more than 1 bps wide"
→ `signedBeat >= 0 && signedBeat <= 1.0`

"about 1/2 bps narrow"
→ `signedBeat < 0 && Math.abs(Math.abs(signedBeat) - 0.5) <= tolerance`

"slightly faster than X-Y"
→ `speed > referenceSpeed && speed <= referenceSpeed + δ`

---

# JavaScript Representation and Utility Functions

Below is a JS module sketch useful for the tuning wizard.

```javascript
// Interval partial pairs (lower note partial, upper note partial).
const INTERVAL_PARTIALS = {
  octave4_2:  { lower: 4, upper: 2 },
  major3rd:   { lower: 5, upper: 4 },
  minor3rd:   { lower: 6, upper: 5 },
  fourth:     { lower: 4, upper: 3 },
  fifth:      { lower: 3, upper: 2 },
  major6th:   { lower: 5, upper: 3 },
  major10th:  { lower: 5, upper: 2 },
};

// Compute the signed beat rate between the coincident partials of two notes.
// Positive = wide, negative = narrow. Returns null if a partial is missing.
function computeSignedBeat(lowerNote, upperNote, interval, detectedPartials) {
  const { lower, upper } = INTERVAL_PARTIALS[interval];
  const fLower = detectedPartials[lowerNote]?.[lower];
  const fUpper = detectedPartials[upperNote]?.[upper];
  if (!fLower || !fUpper) return null;
  return fUpper - fLower;
}

// Evaluate whether the signed beat meets the target relationship.
// target.direction is "wide", "narrow" or undefined (direction not checked).
function evaluateBeat(signedBeat, target, referenceBeat = null) {
  if (signedBeat == null) return false;

  const speed = Math.abs(signedBeat);
  const directionOk =
    target.direction === undefined ||
    (target.direction === "wide" && signedBeat >= 0) ||
    (target.direction === "narrow" && signedBeat <= 0);
  if (!directionOk) return false;

  switch (target.relation) {
    case "absolute":
      return Math.abs(speed - target.value) <= target.tolerance;

    case "lessThan":
      return speed < target.value;

    case "noMoreThan":
      return speed <= target.value;

    case "slightlyFasterThan": {
      if (referenceBeat === null) return false;
      const refSpeed = Math.abs(referenceBeat);
      return speed > refSpeed && speed <= refSpeed + target.delta;
    }

    case "slightlySlowerThan": {
      if (referenceBeat === null) return false;
      const refSpeed = Math.abs(referenceBeat);
      return speed < refSpeed && speed >= refSpeed - target.delta;
    }

    default:
      return false;
  }
}

// Run a single tuning step.
function runTuningStep(step, detectedPartials, referenceBeats) {
  const signedBeat = computeSignedBeat(
    step.lowerNote,
    step.upperNote,
    step.interval,
    detectedPartials
  );

  let refBeat = null;
  if (step.referenceInterval) {
    refBeat = referenceBeats[step.referenceInterval] ?? null;
  }

  const isCorrect = evaluateBeat(signedBeat, step.target, refBeat);

  return {
    ok: isCorrect,
    signedBeat,
    stepDescription: step.description,
    message: isCorrect
      ? "Beat rate is correct. Proceed."
      : `Beat rate off: expected ${step.target.relation}` +
        (step.target.direction ? ` (${step.target.direction}).` : ".")
  };
}
```