Every Log Branch Has Its Own Attractor

Tier: OBSERVATION with a proved proposition inside

Iterate the complex exponential starting from almost any complex number and you diverge to infinity. Iterate the complex logarithm — specifically, the principal branch — and you do the opposite: you spiral inward to a single point near 0.318 + 1.337 i.

That point is the Lambert constant z_0* = −W_0(−1). It’s been known for over a century that principal-log iteration attracts there. What’s less well known is that the same phenomenon happens on every branch, and each branch has its own attractor. There are infinitely many, indexed by the integers.

The structure

Complex exp has a countable family of fixed points: $$ \exp(z) = z \iff z = z_k^* := -W_k(-1), \quad k \in \mathbb{Z}. $$ The principal fixed point z_0* is familiar. The rest sit on a roughly-vertical string in the upper and lower half-planes:

For large k, |z_k*| is roughly 2π|k| — the fixed points live on an almost-evenly-spaced ladder in the imaginary direction.

Every one of them is repelling under exp-iteration: the multiplier exp'(z_k*) = exp(z_k*) = z_k*, and |z_k*| > 1 for all k. Start near any z_k* under exp-iteration and you fly away.

The multiplier flip

Now switch to log-iteration on branch k: $$ \log_k(z) := \log(z) + 2\pi i k. $$ At the point z_k*, the derivative is 1/z_k* (the chain rule of inverse functions), and |1/z_k*| < 1 for every k. The repeller becomes an attractor. Every exp-fixed-point becomes a log-attractor on its matching branch.

This is Proposition 02-B — the exp-log multiplier duality — playing out across the whole integer lattice of branches. The product of multipliers is exactly 1 everywhere: $$ \mathrm{mult}{\exp}(z_k^*) \cdot \mathrm{mult}{\log_k}(z_k^) = z_k^ \cdot \frac{1}{z_k^*} = 1. $$

Verified numerically

Iterate each branch for 300 steps starting from z = 2 + 0i:

Seven seeds, seven convergences, matching the theoretical Lambert values to machine precision. The deeper the branch, the tighter the attractor — |1/z_k*| shrinks like 1/(2π|k|), so branch ±5 pulls in at rate ~0.048 per step.

The attraction rate gets faster with |k|

Because |z_k*| grows as roughly 2π|k|, the log-iteration multiplier shrinks:

Deep branches snap-converge — branch 3 gets within 10^{-15} of z_3* in about 10 iterations from any reasonable seed.

Why principal-log appears to be “the” attractor

Because when you call cmath.log(z) in any programming language, you get the principal branch. Start with any complex number and iterate principal log, you end at z_0*. That’s the version everyone’s seen.

But the Riemann surface of log has countably many sheets, each indexed by a winding number k ∈ ℤ. Each sheet has its own fixed point. Each fixed point is a separate attractor for iteration restricted to that branch.

The picture is symmetric and infinite: a ladder of complex points, all exp-repelling, all log-attracting, tied together by the exp-log multiplier duality.

The branch-cut sensitivity

A practical consequence: when your orbit passes close to the branch cut of log (the negative real axis), a perturbation of 10^{-8} can flip you from one branch’s basin to another’s. In a small experiment with 100 random perturbations of size 10^{-8} applied to seeds on the negative real axis, roughly 46 landed in the same basin as the unperturbed orbit and roughly 54 ended up elsewhere. That 46/54 split is a Lebesgue density of 1/2 in the limit, which is the best-possible instability you can get at a branch cut.

Reproduce

import cmath, math

def log_k(z, k):
    return cmath.log(z) + 2j * math.pi * k

def iterate_branch(k, seed, steps=300):
    z = complex(seed)
    for _ in range(steps):
        z = log_k(z, k)
    return z

for k in range(-5, 6):
    z_star = iterate_branch(k, 2.0)
    print(f"branch k={k:+d}: z_k* = {z_star:.8f}")

Something to try

Each z_k* is a specific, computable complex constant that is not known to be in ELC(ℂ) — the class of numbers expressible by finite EML trees. They’re reachable only as the limit of an iterated EML-style map, not as any finite evaluation. That gap — between “in ELC” and “in the closure of ELC under iteration” — is an open problem.

More on that in a later post.

Cite: Monogate Research (2026). “Every Log Branch Has Its Own Attractor.” monogate research blog. https://monogate.org/blog/lambert-log-branch-attractors