What This Post Is About

In analog computation, we build systems of ODEs that converge to a target value — say, a CRN that computes $\pi$ or $e$. But when we chain these systems together (to compute $\pi + e$, or $1/\alpha$, or $\alpha^\beta$), a natural question arises: does the chaining slow things down?

This post traces two approaches to answering that question:

1. The elementary approach (from a 2019 DNA computing paper): solve the ODE exactly, use integration by parts, bound everything by hand.
2. The low-pass filter approach: rewrite the same ODE in error variables, recognize a universal pattern, get the answer in one step.

These are not different theorems — they’re the same proof, organized differently. The goal of this tutorial is to walk you through the connection slowly enough that you see exactly where the “filter” comes from. No signal processing background needed.

Part 1: The Problem

Suppose a CRN computes a number $\alpha$. That means there’s a species $X$ whose concentration $x(t) \to \alpha$ as $t \to \infty$, with the error decaying exponentially:

Now we want to compute $1/\alpha$. We introduce a new species $Y$ with the ODE:

If $x$ were exactly $\alpha$ (no error), then $y$ would converge to $1/\alpha$. But $x$ has error — it’s still approaching $\alpha$. The question is: does the error in $x$ ruin the convergence of $y$?

Part 2: The Elementary Approach (DNA25)

The 2019 paper proves convergence by brute-force ODE solving.

Step 1: Set up. Write $x(t) = \alpha + h(t)$ where $h(t) = x(t) - \alpha$ is the input error, $|h(t)| \le e^{-t}$. Define $F(t) = \int_0^t x(s) ds = \alpha t + H(t)$ where $H(t) = \int_0^t h(s) ds$.

Step 2: Solve exactly. Using the integrating factor $e^{F(t)}$:

Step 3: The key move — integration by parts. Rewrite the integral:

Now set $u(s) = e^{H(s)}$ and $v'(s) = e^{\alpha s}$, so $v(s) = e^{\alpha s}/\alpha$. Integration by parts gives:

Step 4: Cancel and bound. Substituting back and using $e^{F(t)} = e^{\alpha t + H(t)}$:

Step 5: Control the constants. Since $|h(t)| \le e^{-t}$ is integrable, $|H(t)| \le C_1$ (bounded!). This means $e^{F(t)} \approx e^{\alpha t}$ up to constants. Working through the bounds:

Done. The reciprocal converges exponentially. The proof uses nothing beyond integrating factors, one integration by parts, and careful bookkeeping of constants.

Part 3: The Upgrade — One Conceptual Step

Now let’s do the same thing differently. Instead of solving for $y$ and then extracting the error, let’s start with the error.

Define the error variables:

• $\delta(t) = y(t) - 1/\alpha$ (how far the output is from its target)
• $\epsilon(t) = x(t) - \alpha$ (how far the input is from its target)

Substitute into the ODE $y' = 1 - xy$:

The last term $\epsilon\delta$ is the product of two small quantities (input error times output error). For the purpose of understanding the dominant behavior, we drop it:

That’s the entire upgrade. We went from the original ODE (in terms of $y$ and $x$) to an error equation (in terms of $\delta$ and $\epsilon$). No new mathematics — just a change of variables.

Part 4: Reading the Error Equation

Let’s stare at $\dot{\delta} + \alpha\delta = -\epsilon(t)/\alpha$ and understand what it says.

The left side, $\dot{\delta} + \alpha\delta$, describes a system that pulls $\delta$ toward zero at rate $\alpha$. If there were no driving term (if $\epsilon = 0$), the solution would be $\delta(t) = \delta(0) e^{-\alpha t}$: the error decays exponentially at rate $\alpha$. This is the system’s intrinsic recovery speed.

The right side, $-\epsilon(t)/\alpha$, is the disturbance. As long as $\epsilon(t) \ne 0$ — meaning the input hasn’t fully converged yet — this term keeps nudging $\delta$ away from zero. (The sign doesn’t matter here: whether $\epsilon$ is positive or negative, it creates a nonzero driving force that prevents $\delta$ from settling.)

The question becomes: which force wins — the pull-back or the disturbance?

• If $\epsilon(t)$ decays slowly (slower than $e^{-\alpha t}$), the system easily keeps up. The output error just tracks the input error: $\delta(t) \approx \epsilon(t)/\alpha$. No slowdown.

• If $\epsilon(t)$ decays fast (faster than $e^{-\alpha t}$), the input vanishes quickly, but the system can only forget past disturbances at its own rate $\alpha$. The output error gets stuck at $e^{-\alpha t}$. Throttled.

Part 5: Solving It (One Line)

The solution to $\dot{\delta} + \alpha\delta = g(t)$ by integrating factor $e^{\alpha t}$ is:

The integral is a weighted sum over the entire history of the driving term $g$. The weight for each past time $s$ is $e^{-\alpha(t-s)}$: recent inputs ($s \approx t$) have weight $\approx 1$, old inputs ($s \ll t$) have weight $\approx 0$. The system remembers the recent past and forgets the distant past.

This weighted sum is called a convolution. The weight function $h(\tau) = e^{-\alpha\tau}$ is called the impulse response: it’s how the system reacts to a single instantaneous kick.

Engineers call this a low-pass filter: slow signals pass through, fast signals are filtered out. But why? Let’s see it directly from the integral.

Why slow signals pass through. Suppose $g(s)$ changes very slowly — say $g(s) \approx g(t)$ over the window where the weight $e^{-\alpha(t-s)}$ is significant (roughly $s \in [t - 3/\alpha, t]$). Then we can pull $g$ out of the integral:

The output is proportional to the current input. The filter is transparent — it just passes $g(t)$ through with a constant factor.

Why fast signals get filtered out. Now suppose $g(s) = C e^{-\beta s}$ with $\beta \gg \alpha$. The input decayed to near-zero long ago, but the system accumulated some disturbance in the past and can only forget it at rate $\alpha$. Evaluating the integral:

The fast input ($e^{-\beta t}$) is gone, but the output decays only as $e^{-\alpha t}$ — the system’s own forgetting rate. The fast signal has been filtered out, replaced by the system’s slower response.

One more way to say it: the subtraction module, on its own, converges in linear time — with constant inputs, it gets $r$ bits of precision in $\Theta(r)$ time. But when the upstream input converges more slowly (say, in $\Theta(r \log r)$ time), the module can’t accelerate it. The output inherits the slower rate. A fast module cannot speed up a slow input; it can only slow down a fast one. That’s the low-pass property in one sentence.

If you can solve $y' + cy = g(t)$ with an integrating factor, you already understand low-pass filters.

Part 6: The Connection

The DNA25 proof and the low-pass filter view are the same proof. Here’s the dictionary:

The DNA25 integration by parts is the convolution integral, computed in the coordinate system of the original variables rather than the error variables. The constants $C_6$ and $C_7$ encode the two regimes that the filter view makes explicit.

Part 7: The Same Upgrade for Anderson–Joshi Subtraction

The DNA25 reciprocal module computes $1/\alpha$ via $y' = 1 - x(t)\cdot y$. Anderson and Joshi (2024) compute $|a^* - b^*|$ via a different CRN module:

Under mass-action kinetics, this gives:

where $x_1(t) = A(t) - B(t) \to \alpha = a^* - b^*$ and $Z^* = \alpha$.

Let’s apply the same upgrade. Set $\delta = Z - \alpha$ and $\epsilon = x_1 - \alpha$:

Drop the higher-order terms $\epsilon\delta$ and $\delta^2$:

It’s the same pattern again! A first-order linear ODE with cutoff frequency $\alpha$.

Compare all three:

All three are the same filter $\dot{\delta} + c\delta = g(t)$, just with different cutoff frequencies and driving terms. The analysis from Parts 4–6 applies identically to all of them.

One difference worth noting: the DNA25 reciprocal has cutoff $\alpha$ with driving coefficient $1/\alpha$, while Anderson–Joshi has cutoff $\alpha$ with driving coefficient $\alpha$. This doesn’t affect which regime you’re in (that depends on how fast $\epsilon$ decays compared to $e^{-\alpha t}$), but it does affect the constant factor in the output error.

For the DNA25 two-reciprocal method (computing $\alpha - \beta$ via two sequential inversions), the cascade has effective speed $\min(\alpha, 1/\alpha)$ — the bottleneck is the slower of the two filters. For Anderson–Joshi, the speed is simply $\alpha$. When $\alpha > 1$, Anderson–Joshi is faster; when $\alpha < 1$, the two-reciprocal method can be comparable. See CRN Subtraction Is a Low-Pass Filter for simulations comparing the two.

Part 8: Why Bother Upgrading?

For the DNA25 paper, the elementary approach was perfect. The input always decays as $e^{-t}$, and you just need exponential convergence. Two lemmas, two proofs, done.

But what if the input decays at a different rate? What if it decays as $1/t^k$ (polynomial), or $e^{-\sqrt{t}}$, or $e^{-t/\log t}$? In bounded analog complexity, we have a whole hierarchy of convergence rates, and we need to know whether each readout module preserves the rate.

The filter view answers all these cases at once:

One proof, all cases. That’s the upgrade: not new mathematics, but a new organizing principle that turns case-by-case analysis into a single pattern.

Summary

1. The DNA25 paper proves convergence of CRN arithmetic by solving ODEs with integrating factors and integration by parts. Clean, elementary, correct.

2. Rewriting in error variables gives the universal pattern: output error satisfies a first-order linear ODE with constant coefficient.

3. This pattern appears in every CRN arithmetic module: DNA25 addition, DNA25 reciprocal, Anderson–Joshi subtraction. Same ODE, different cutoff frequency.

4. The solution is a convolution — a weighted average of past inputs with exponentially decaying weights. Engineers call this a “low-pass filter.” Mathematicians call it Green’s function.

5. The upgrade buys generality: instead of proving each operation separately, one pattern covers addition, multiplication, reciprocal, subtraction, and exponentiation, for any input decay rate.

Related posts:

• CRN Subtraction Is a Low-Pass Filter — the full analysis with simulations
• How Hard Is It to Compute α^β? — where the same filter shows up inside a GPAC construction