1 files changed, 98 insertions, 0 deletions
diff --git a/module-design.typ b/module-design.typ
new file mode 100644
index 0000000..d6e737b
--- /dev/null
+++ b/module-design.typ
@@ -0,0 +1,98 @@
+#import "@preview/unify:0.8.1": numrange, qty, qtyrange
+
+= Module design <module-design>
+
+The preceding sections established what SAME is: its signal standards, precision
+tiers, power distribution, and mechanical format. This section addresses how
+SAME modules are designed to meet these specifications — particularly the
+demanding requirements of the Metrologic tier.
+
+The challenge is substantial. The Metrologic tier demands $qty(10, "ppm")$
+precision, $qty(90, "dB")$ signal-to-noise ratio, and
+$qty(0.014, "ppm per hour")$ drift over a DC to $qty(20, "kHz")$ bandwidth.
+These specifications, taken together, require that a $qty(20, "V")$ signal range
+be resolved to $qty(200, "uV")$, that noise remain below $qty(632, "uV") upright("RMS")$,
+and that accumulated drift not exceed $qty(10, "ppm")$ over thirty days of
+continuous operation. Achieving this with commodity through-hole components —
+resistors, capacitors, and op-amps available from any electronics distributor —
+would appear to be impossible. The tolerances of standard components are
+measured in percent, not parts per million. The temperature coefficients of
+common resistors would exhaust the entire drift budget in minutes, not months.
+
+Yet it is possible. The gap between component specifications and system
+requirements is bridged not by exotic parts but by topology: the deliberate
+arrangement of ordinary components into configurations where their errors
+cancel, track, or become irrelevant to the computation. A resistor's absolute
+value may be uncertain to 1%, but its ratio to an adjacent resistor from the
+same batch, at the same temperature, can be stable to $qty(10, "ppm")$. An
+amplifier's offset voltage may drift by microvolts per degree, but a servo loop
+can continuously measure and nullify that drift faster than it accumulates.
+A multiplier's nonlinearity may be limited by transistor physics to
+$qty(0.1, "percent")$, but encoding the multiplication in the time domain rather
+than the amplitude domain sidesteps those physics entirely.
+
+These techniques are not novel. They are the accumulated wisdom of precision
+analog design, developed by metrologists and instrumentation engineers over
+seven decades. What SAME contributes is their systematic application within
+constraints that matter for sustainability and sovereignty: through-hole
+construction that can be assembled and repaired with basic equipment, open
+documentation that enables understanding rather than mere replication, and
+component choices that will remain available as specific part numbers inevitably
+become obsolete.
+
+This section proceeds in six parts.
++ #ref(<module-design-terminology>) establishes terminology. Precision analog
+  design has a specialized vocabulary; ambiguous terms lead to ambiguous
+  analysis. We define our terms once, carefully, and use them consistently
+  throughout.
++ #ref(<module-design-modules-categories>) categorizes the three types of SAME
+  modules — Interface, Compute, and Control — and specifies the requirements
+  particular to each category. Not all modules face identical constraints; a
+  control module generating voltages from a front-panel knob operates under
+  different rules than a compute module performing four-quadrant multiplication.
++ #ref(<error-budgeting-and-system-level-compensation>) develops the error
+  budget framework. We enumerate every source of error in a precision analog
+  signal path, quantify each source using commodity component specifications,
+  and construct the naive error budget that results from conventional design.
+  This budget exceeds our specifications by factors ranging from $11$ to $4000$.
+  The purpose of this exercise is not despair but clarity: we must know
+  precisely where the errors arise before we can systematically eliminate them.
++ #ref(<error-compensation-strategies>) presents the five fundamental
+  compensation strategies that close the gap between naive and Metrologic
+  performance. Each strategy is developed from physical principles, analyzed
+  mathematically, and specified with design rules sufficient to implement it
+  correctly.
++ #ref(<advanced-compensation-topologies>) extends these techniques for
+  applications demanding performance beyond the base Metrologic specification.
+  They can push precision into the 1-5ppm range for specialized applications.
+  These techniques are optional — the base compensation strategies suffice for
+  Metrologic tier — but they demonstrate that the approach has headroom.
++ #ref(<implicit-computation>) introduces implicit computation, a
+  design philosophy where mathematical operations emerge from feedback
+  equilibrium rather than explicit signal processing. Division, for example, can
+  be implemented explicitly using logarithms (with their associated
+  nonlinearity) or implicitly using a multiplier in a feedback loop (where the
+  loop forces the quotient to whatever value satisfies the multiplication).
+  Implicit designs often achieve superior precision because the feedback loop
+  continuously corrects errors that would accumulate in an explicit signal
+  chain.
+
+The reader seeking to understand how the reference implementation in
+#ref(<reference-implementation>) achieves its specifications, or to design new
+modules, will find the theoretical foundation here. We make no apology for the
+depth of what follows. Precision is not achieved by accident or by following
+recipes without understanding. It is achieved by understanding the physics
+deeply enough to make the physics work for you rather than against you.
+
+== Terminology <module-design-terminology>
+
+== Module categories <module-design-modules-categories>
+
+== Error budgeting and system-level compensation
+<error-budgeting-and-system-level-compensation>
+
+== Error compensation strategies <error-compensation-strategies>
+
+== Advanced compensation topologies <advanced-compensation-topologies>
+
+== Implicit computation <implicit-computation>