The Setup

Computing $1/\alpha$ is the central primitive in analog computing. Every time you want to divide, subtract, or take a reciprocal, you need a module that accepts a signal $x(t) \to \alpha$ as input and produces an output $y(t) \to 1/\alpha$.

In CRN (Chemical Reaction Network) computing, there are two natural ODEs that accomplish this. One is well known. The other, I realized recently, is hiding a beautiful connection to Newton’s method.

Module 1: The Linear Reciprocal

The standard construction from Huang, Klinge, Lathrop, Li, Lutz (DNA25, 2019) uses:

When $x(t) = \alpha$ (constant), the equilibrium is $y^* = 1/\alpha$, and $y(t) \to 1/\alpha$ at rate $e^{-\alpha t}$.

In CRN terms, this comes from two reactions:

The first reaction produces $Y$ at a constant rate. The second degrades $Y$ at a rate proportional to $X$. At equilibrium, production balances degradation: $1 = \alpha \cdot y^*$, so $y^* = 1/\alpha$.

This is the module used in Lemma 7 of the DNA25 paper to prove $\mathbb{R}_{RTCRN}$ is closed under reciprocal. It works beautifully from $y(0) = 0$: the zero initial condition is natural for a newly introduced species, and $y$ climbs smoothly toward $1/\alpha$.

But the convergence rate depends on $\alpha$. When $\alpha$ is small (computing the reciprocal of a small number), the rate $e^{-\alpha t}$ is slow. The module’s intrinsic speed is proportional to the target value — smaller $\alpha$ means slower convergence.

Module 2: The Quadratic Reciprocal

There is another ODE that also computes $1/\alpha$:

When $x(t) = \alpha$ (constant), the equilibrium is again $y^* = 1/\alpha$. But the dynamics are different. Making the substitution $w = 1/y$, we get $w' = -y'/y^2 = -(1 - \alpha/w) = \alpha - w$, which gives $w(t) = \alpha + (w_0 - \alpha)e^{-t}$, so:

The convergence rate is $e^{-t}$, independent of $\alpha$. Whether you’re computing $1/0.001$ or $1/1000$, the module converges at the same speed.

In CRN terms:

The first reaction is autocatalytic growth. The second is density-dependent degradation catalyzed by $X$. At equilibrium, $y^* = \alpha \cdot (y^*)^2$, giving $y^* = 1/\alpha$.

There’s a catch: $y = 0$ is a fixed point. If $y(0) = 0$, the autocatalytic reaction never fires, and $y$ stays at zero forever.

The Newton Connection

Where does the quadratic module come from? Here’s the observation that stopped me in my tracks.

The quadratic reciprocal module is the continuous Newton’s method for computing $1/\alpha$.

Newton’s method for finding a root of $f(z) = 0$ is the iteration $z_{n+1} = z_n - f(z_n)/f'(z_n)$. Its continuous analog is the ODE:

Now consider the function $f(z) = 1/z - \alpha$, whose root is $z^* = 1/\alpha$. We have $f'(z) = -1/z^2$, so:

That’s the quadratic reciprocal module.

This explains the $\alpha$-independent convergence rate. In discrete Newton’s method, the number of correct digits doubles with each iteration — the convergence is quadratic and independent of the function’s parameters (near the root). In continuous Newton’s method, the exponential convergence rate depends only on the linearization at the root. For $f(z) = 1/z - \alpha$:

The eigenvalue at the fixed point is $-1$, always. This is why the rate is $e^{-t}$ regardless of $\alpha$.

Filter Analysis: Why the Rates Differ

In a previous post, I showed that CRN modules are low-pass filters. Let’s apply that analysis to both reciprocal modules.

Linear module: $y' = 1 - x(t)y$. Setting $\delta = y - 1/\alpha$ and $\epsilon = x - \alpha$:

Low-pass filter with cutoff frequency $\alpha$. Slow inputs (converging slower than $e^{-\alpha t}$) pass through transparently. Fast inputs get throttled to $e^{-\alpha t}$.

Quadratic module: $y' = y(1 - x(t)y)$. Setting $\delta = y - 1/\alpha$ and $\epsilon = x - \alpha$:

Keeping only the leading terms:

Low-pass filter with cutoff frequency $1$. Always.

Here’s the comparison:

The linear module’s bandwidth scales with $\alpha$: computing $1/\alpha$ for small $\alpha$ is slow because the filter can’t keep up. The Newton module’s bandwidth is constant: it always converges at rate $e^{-t}$, with the $\alpha$-dependence pushed entirely into the driving amplitude $\epsilon/\alpha^2$.

The Tradeoff

So why does the DNA25 paper use the linear module instead of the faster Newton module?

The zero-IC problem. In CRN computing, newly introduced species start at concentration zero. The linear module works perfectly from $y(0) = 0$: production starts immediately ($y' = 1 > 0$ at $t = 0$), and $y$ climbs toward $1/\alpha$.

The Newton module is stuck at $y(0) = 0$ forever. The autocatalytic reaction $Y \to 2Y$ needs existing $Y$ molecules to fire. No molecules, no reaction, no computation.

This isn’t just a technical inconvenience — it reflects a fundamental property of continuous Newton’s method. Newton’s iteration $z_{n+1} = z_n - f(z_n)/f'(z_n)$ requires an initial guess $z_0 \ne z^*$ in the basin of attraction. You need to start somewhere. The linear module, by contrast, is a forced system: the constant production term $1$ acts as an external drive that pushes $y$ away from zero regardless of initial conditions.

In practice, this can be resolved. Theorem 3 of the DNA25 paper shows that integer initial conditions can be absorbed into a zero-initialized system via a change of variables. Setting $y(0) = 1$ (an integer) gives the Newton module a valid starting point, and the theorem handles the rest.

A Spectrum of Reciprocal Modules

Stepping back, we can see both modules as points on a spectrum. Consider the family:

for $k = 0, 1, 2, \ldots$ The equilibrium is always $y^* = 1/\alpha$.

• $k = 0$: The linear module. $y' = 1 - xy$. Filter cutoff $\alpha$. Works from $y(0) = 0$.
• $k = 1$: The Newton module. $y' = y(1-xy)$. Filter cutoff $1$. Stuck at $y(0) = 0$.
• $k = 2$: Halley-type. $y' = y^2(1-xy)$. Filter cutoff $1/\alpha$. Even faster for large $\alpha$.

Higher $k$ gives faster convergence (at least when $\alpha > 1$), but the zero-IC problem only gets worse: $y = 0$ becomes a higher-order fixed point.

The Newton module ($k = 1$) is the sweet spot: uniform convergence rate with only a simple (first-order) zero at $y = 0$.

What This Means for Complexity

In the bounded analog complexity hierarchy, the convergence rate of each module determines the time complexity of the full computation. The low-pass filter view says: if the upstream signal converges at rate $\mu(r)$, the downstream module’s output converges at rate $\max(\mu(r), r/c)$, where $c$ is the cutoff frequency.

For the linear reciprocal module with cutoff $\alpha$:

• If $\alpha = O(1)$, the module is already fast enough. No slowdown.
• If $\alpha = o(1)$ (computing the reciprocal of a vanishing quantity), the module becomes the bottleneck. The filter throttles.

For the Newton reciprocal module with cutoff $1$:

• The module is never the bottleneck, regardless of $\alpha$. The cutoff is fixed at $1$.

This suggests that the Newton module could simplify proofs in the bounded complexity hierarchy. When building cascaded systems (computing $1/(1/\alpha) = \alpha$, or $\alpha/\beta = \alpha \cdot (1/\beta)$), the Newton module’s $\alpha$-independent rate avoids the cascade slowdown that plagues the linear module.

The Continuous Newton Perspective

There’s a broader lesson here. Newton’s method is usually thought of as a tool for numerical computation — a way to find roots quickly. But in the context of analog computing, it’s a design principle for dynamical modules.

Any time you need a dynamical system that converges to a target determined by parameters, you have (at least) two choices:

1. Linear tracking: Design a system where the target is an attractor with parameter-dependent eigenvalue. Simple, robust, works from arbitrary initial conditions.

2. Newton tracking: Design a system where the target is a root of some function, and the dynamics follow the continuous Newton flow. The eigenvalue at the root depends only on the function’s geometry, not its parameters.

The linear approach is what control engineers call a proportional controller. The Newton approach is something else — a geometry-aware controller that exploits the structure of the problem to achieve parameter-independent convergence.

Whether this perspective leads to faster CRN constructions in practice is an open question. But the connection itself — that the standard reciprocal module and continuous Newton’s method are two points on the same spectrum of analog computing primitives — feels like it deserves to be noticed.

Summary

1. The CRN reciprocal module $y' = 1 - xy$ from the DNA25 paper is a low-pass filter with cutoff $\alpha$. It converges at rate $e^{-\alpha t}$, which depends on the target value.

2. The alternative module $y' = y(1-xy)$ is continuous Newton’s method for $f(z) = 1/z - \alpha$. It converges at rate $e^{-t}$, independent of $\alpha$.

3. Newton’s method gives uniform convergence because the eigenvalue at the fixed point is $-1$, always. The linear module’s eigenvalue is $-\alpha$, which varies.

4. The tradeoff: Newton gets stuck at $y(0) = 0$ (needs a nonzero seed), while the linear module works from zero initial conditions.

5. Both modules are CRN-implementable. They represent two design philosophies: forced linear tracking vs. geometry-aware Newton tracking.

Related posts:

• Newton’s Method, Complex Dynamics, and the GPAC Connection — the original observation connecting Newton’s method to analog computing
• A Gentle Upgrade: From Integration by Parts to Low-Pass Filters — the filter framework used in this analysis
• CRN Subtraction Is a Low-Pass Filter — the same filter perspective applied to subtraction modules