Upgrading Extremal Flows in the Space of Derivatives

The Big Picture: Navigating a Mountain Range

Imagine you are trying to find the highest peak in a vast, foggy mountain range. This mountain range represents the "space of solutions" for a complex physics problem called the Conformal Bootstrap. Physicists use this method to figure out the rules of quantum field theories (the laws governing particles and forces) without needing to know the specific details of the particles, just by using general mathematical rules.

Usually, scientists use a heavy, slow, but very reliable machine (called an SDP solver or sdpb) to climb these mountains. It works by checking every possible path to ensure it's safe (mathematically "positive"). However, this machine is slow, especially when you want to climb higher and get more precise results.

The Author's Goal:
Rajeev Erramilli wants to build a faster, more agile way to climb these mountains. He is upgrading a method called "Extremal Flows." Think of this not as a machine that checks every path, but as a hiker who knows the terrain. If you know the location of a peak at a low altitude, you can use that knowledge to guess where the peak will be at a higher altitude, then take small steps to get there. This is called "hotstarting" or "upgrading."

The Problem: The "Staircase" is Broken

The author's method works great for simple, flat mountains (simple physics problems). But when he tried to apply it to a more complex, spinning mountain (the Spinning Modular Bootstrap), he hit a wall.

The method relies on taking a solution from a "low-resolution" map (few details) and upgrading it to a "high-resolution" map (many details).

The Analogy: Imagine you have a sketch of a face with 7 lines (low resolution). You want to turn it into a photo with 22 lines (high resolution).
The Glitch: As the author tried to add those extra lines, the math broke. The "hiker" would suddenly step off a cliff because the path became unstable. The equations would become "singular" (mathematically broken), and the hiker wouldn't know which way to turn.

The Solution: A Systematic Way to "Branch Hop"

The paper presents a new set of rules to fix these glitches. Here is how the author solves the problems, using metaphors:

1. The Smooth Ramp (The "Beta" Flow)

Instead of trying to jump instantly from the 7-line sketch to the 22-line photo, the author creates a smooth ramp (a parameter called $\beta$ ).

He starts at the bottom ( $\beta=0$ ) with the known solution.
He slowly moves up the ramp ( $\beta=0.1, 0.2, \dots$ ) to the top ( $\beta=1$ ).
At every tiny step, he checks if the solution is still valid. This prevents the hiker from falling off a cliff because the steps are small and controlled.

2. The "Branch Hop" (Fixing the Cliffs)

Sometimes, even with small steps, the hiker reaches a fork in the road where the path splits.

The Problem: One path leads to a safe, positive solution. The other path leads to a "negative" solution (which is physically impossible in this context, like a mountain going underground).
The Fix: The author developed a "Branch-Hopping" algorithm. When the hiker detects they are about to step onto the "negative" path, the algorithm instantly snaps them over to the correct, safe path. It's like having a GPS that says, "Don't go left, the bridge is out; go right."

3. The "Jacobian" Glitch (The Under-constrained Map)

Sometimes, the map becomes so vague that there are too many possible paths (the math is "under-constrained").

The Fix: The author realized that when the map gets vague, there is usually a specific "edge" or boundary where a new path appears. His algorithm finds this boundary, adds a new "landmark" (a new operator or zero) to the map, and suddenly the path becomes clear again. It's like realizing you need to add a new street sign to stop getting lost.

The Result: A Prototype That Works (But Has Limits)

The author built a computer program (a prototype) to test this on a specific, difficult physics problem: the Spinning Modular Bootstrap (which deals with 2D quantum theories with "spin").

The Test: He successfully upgraded a solution from a low level ( $N=7$ ) to a high level ( $N=22$ ).
The Catch: While the method worked, it turned out to be surprisingly chaotic.
- The "Spin-Hopping" Killer: As the solution climbed the mountain, the "spin" of the particles (a property like rotation) would jump around wildly. The algorithm had to stop, fix the path, and start again dozens of times.
- The Verdict: The author admits that while this method is a brilliant proof-of-concept that can upgrade solutions, it is currently slower than the traditional, heavy machine (sdpb) for this specific problem. The "hiker" spends too much time fixing the path to be faster than the "machine" that just brute-forces the answer.

Summary

This paper is a technical manual for a new type of mathematical hiker.

The Idea: Use small, smooth steps to upgrade physics solutions from low detail to high detail.
The Innovation: A set of rules to automatically fix the path when it breaks (branch-hopping) or gets too vague (curing singularities).
The Outcome: The author successfully built a prototype that can climb a very difficult mountain (the spinning modular bootstrap) from start to finish.
The Reality Check: The climb was full of detours and stops. The author concludes that while the method is robust and proves the concept works, it isn't yet fast enough to replace the standard tools used by physicists today. It is a successful prototype, not a finished product ready for mass production.

1. Problem Statement

The paper addresses a specific bottleneck in the Conformal Bootstrap program, particularly within the context of numerical optimization.

Current State: The standard approach uses Semidefinite Programming (SDP) solvers (like sdpb) to find optimal bounds on CFT data. These solvers treat the problem as a convex optimization task.
The Limitation: While robust, SDP solvers are computationally expensive due to the need for arbitrary-precision arithmetic. A significant inefficiency arises when increasing the numerical order (the number of derivatives or functional components, denoted as $N$ ). To refine results, one must typically restart the optimization from scratch at $N+1$ , discarding the information gained at $N$ .
The Gap: Previous attempts to use Extremal Flows (a method where one "flows" from a solution at $N$ to $N+1$ by solving a system of nonlinear equations) have been limited to simple cases (e.g., 1D CFTs or spinless modular bootstrap). They lack a robust, systematic procedure for upgrading solutions in complex, higher-dimensional, or spinning scenarios where the structure of the solution (the spectrum of operators) changes discontinuously.

2. Methodology

The author develops a generalized framework for upgrading extremal flows, allowing solutions to be tracked continuously as the numerical order $N$ increases. The methodology involves several key theoretical and algorithmic components:

A. Theoretical Framework: Smooth Deformation

To bridge the gap between a solution at order $N$ and order $N+1$ , the author introduces a continuous parameter $\beta \in [0, 1]$ .

Interpolation: A family of equations $E_\beta$ is constructed such that $E_0$ corresponds to the known solution at $N$ and $E_1$ corresponds to the target system at $N+1$ .
Modified Identity: The interpolation is achieved by modifying the "identity" contribution in the crossing equation. This ensures that for every $\beta$ , the system corresponds to a valid convex optimization problem (SDP), guaranteeing the existence of a unique, positive solution.
Flowing: The solution is tracked by incrementally stepping $\beta$ from 0 to 1 using numerical root-finding methods (e.g., Newton's method).

B. Handling Discontinuities: Branch-Hopping

A major challenge is that the solution space is not always smooth; operators can appear or disappear, and positivity can be violated.

Positivity Violations: As $\beta$ increases, coefficients ( $\rho_i$ ) may become negative, or the functional ( $\alpha \cdot F$ ) may develop untracked zeroes (regions of negativity).
Branch-Hopping: When a violation occurs, the algorithm identifies the exact point $\beta^*$ $β^{*}$ where the violation happens (e.g., $\rho_i = 0$ $ρ_{i} = 0$ or a new zero forms). At this point, the system of equations is modified:
- If $\rho_i \to 0$ , the constraint enforcing a double zero at that operator is removed.
- If a new zero forms, a new constraint is added to track it.
- This "branch-hopping" allows the flow to continue on a new branch of solutions that maintains positivity.

C. Curing Jacobian Singularities

A critical technical contribution is the handling of singular Jacobians that occur when the number of free variables does not match the number of constraints (specifically when the number of bulk operators is too low relative to the number of functional components).

Underconstrained Systems: When the Jacobian is singular, the functional $\vec{\alpha}$ $α$ is underdetermined. The author proposes a deterministic procedure to resolve this:
1. Parametrize the degenerate family of solutions as $\vec{\alpha}(t) = \vec{\alpha}_0 + t\vec{\alpha}_1$ .
2. Find the values of $t$ where $\vec{\alpha}(t)$ develops a new zero (the boundary of positivity).
3. Select the branch that maintains positivity as $\beta$ increases, effectively adding a new tracked operator to resolve the degeneracy.

D. Modular Bootstrap Specifics

The method is applied to the Spinning Modular Bootstrap (2D CFTs on a torus).

Block Topology: The author analyzes the topology of modular blocks, introducing a compactified coordinate $x$ for twist and handling the limit of infinite spin ( $s \to \infty$ ).
Infinite Spin Limit: The paper derives that blocks at infinite spin and finite twist meet at a junction ( $x=1$ ). This topology dictates how operators can "transmute" between fixed boundary operators and bulk operators during the flow.

3. Key Contributions

Generalized Upgrading Algorithm: A robust, systematic procedure to upgrade extremal flow solutions from low to high numerical order ( $N \to N+1$ ) for complex bootstrap problems, moving beyond simple 1D cases.
Deterministic Singularity Resolution: A novel algorithm to cure Jacobian singularities without guesswork, ensuring the flow remains unique and positive even when the number of operators changes.
Topological Insight: A detailed analysis of the topology of modular blocks, specifically the behavior of operators at infinite spin and the "junction" at $x=1$ , which is crucial for maintaining numerical stability in spinning bootstrap problems.
Prototype Implementation: The development of a prototype code (in Mathematica) that successfully implements these algorithms.

4. Results

The author applies the methodology to the $c=5$ Spinning Modular Bootstrap, upgrading the solution from $N=7$ to $N=22$ .

Success: The prototype successfully tracks the evolution of the spectrum (scaling dimensions $\Delta$ and coefficients $\rho$ ) across the entire range.
Challenges Observed:
- Jacobian Singularities: The flow encountered singularities immediately at $N=8$ and again at $N=10$ , requiring the algorithm to add new operators (including operators at "infinity") to proceed.
- Spin-Hopping: A significant performance bottleneck was identified. As $N$ increased, the functional developed regions of negativity that migrated across integer spins. This forced the algorithm to perform "branch-hopping" repeatedly (adding/removing operators) for many spins.
Performance: The upgrading process was found to be computationally intensive. The frequent need to backtrack and solve for branching points (often 20–40 times) negated the potential speedup over standard SDP solvers like sdpb for this specific test case.

5. Significance and Conclusion

Theoretical Value: The paper demonstrates that the space of bootstrap solutions is rich and complex, with non-trivial topological features (like the junction at $x=1$ ) that must be respected to maintain positivity. It proves that extremal flows can be made robust enough to handle these complexities.
Practical Limitations: While the method works, the current implementation is not yet faster than sdpb for unitary CFTs due to the overhead of managing branch-hopping and Jacobian singularities.
Future Directions: The author suggests that the method could be improved by:
- Using more efficient functional bases (e.g., analytic functionals).
- Relaxing constraints on continuous spin to reduce the number of branch-hopping events.
- Utilizing the continuous family of SDPs ( $SDP_\beta$ ) to perform "hot-starting" with traditional solvers, potentially combining the best of both worlds.

In summary, this work provides a crucial theoretical and algorithmic foundation for extremal flow upgrading, revealing both the potential for efficient bootstrap calculations and the significant technical hurdles (specifically regarding spin-cascades and Jacobian singularities) that must be overcome to realize that potential.