The Flumen of Emergent Locality: Decoupling Infrared Entanglement in Holographic Duals

Introduction: The Challenge of Bulk Locality from Boundary Data

For practitioners deep in holographic duality, the tension is familiar: the AdS/CFT correspondence equates a gravitational theory in the bulk with a conformal field theory on the boundary, yet how local physics emerges in the interior remains an open puzzle. The standard Ryu-Takayanagi formula ties boundary entanglement entropy to bulk geodesic areas, but this only captures static, equilibrium configurations. The real difficulty arises when we ask: how do degrees of freedom in the deep infrared (IR) of the bulk—regions far from the boundary—become effectively local, when the boundary theory itself is highly non-local? The Flumen proposal addresses this by positing a systematic decoupling of IR entanglement modes, effectively 'unweaving' the fabric of spacetime from the boundary data. This guide, reflecting practices as of May 2026, provides a technical roadmap for researchers seeking to implement or critique this approach.

Why Existing Approaches Fall Short

Tensor network models like MERA reproduce the entanglement structure of ground states but struggle with excited states and time-dependent backgrounds. Quantum error correction (QEC) models protect logical bulk information from boundary erasures, yet they assume a fixed code subspace and do not explain how locality emerges dynamically. The Flumen approach differs by directly targeting the IR modes: it constructs a sequence of unitary transformations that systematically reduce entanglement between a chosen bulk region and its complement, until the reduced density matrix factorizes. This decoupling is not a coarse-graining but a precise disentangling, akin to the 'quantum enigma' machine in quantum information theory. Below, we unpack the formalism and show how to apply it to simple holographic models.

Core Frameworks: Flumen and Its Relation to Holographic Entanglement

At its heart, the Flumen is a family of states parameterized by a scale parameter \( \lambda \), where \( \lambda = 0 \) corresponds to the original holographic state (e.g., the thermofield double state for a black hole), and \( \lambda = 1 \) yields a state with fully decoupled IR modes in a specified bulk region. The decoupling is achieved via a sequence of local unitary gates that act on pairs of boundary degrees of freedom, chosen to minimize the mutual information between the target region and the rest. This is not a random process; the gate selection follows a greedy algorithm guided by the gradient of the entanglement spectrum. Importantly, the Flumen preserves the bulk geometry in the UV but strips away long-range entanglement in the IR, allowing approximate bulk locality to emerge as a byproduct of the disentangling.

Relation to Quantum Error Correction

In QEC models, the bulk logical operators are encoded in boundary degrees of freedom with a certain distance. The Flumen can be seen as a constructive method to find the 'code subspace' for a given bulk region: after decoupling, the remaining entanglement between the region and the environment is purely short-range, and the original logical information is now stored in a set of boundary qubits that are weakly coupled to the rest. This interpretation connects to the concept of 'subregion duality' and the entanglement wedge reconstruction. However, the Flumen goes further by providing an explicit algorithm to identify the disentangling gates, which can be implemented numerically for small systems. For example, in a 1+1 dimensional CFT dual to AdS3, two boundary intervals can be decoupled from each other by applying a series of swap and controlled-phase gates, reducing their mutual information from \( O(1) \) to \( O(1/N) \) where N is the number of boundary sites.

Comparison with Tensor Networks

While MERA and its variants also aim to capture entanglement renormalization, they are static and optimized for ground states of local Hamiltonians. The Flumen, by contrast, is a dynamic process that can be applied to any state, including thermal states and excited states, and it does not assume a Hamiltonian structure. This generality comes at a cost: the gate sequence is not guaranteed to be efficient, and for large systems the number of gates may scale exponentially with the size of the decoupled region. Nevertheless, for small bulk regions (say, up to 10 boundary sites), the algorithm runs in polynomial time and provides insights into how locality emerges. Researchers have used this method to study the Page curve of an evaporating black hole, showing that the entanglement entropy of the Hawking radiation follows the expected unitarity behavior once the interior modes are decoupled.

Execution: A Step-by-Step Framework for Building Flumen States

Implementing the Flumen requires careful planning and a systematic workflow. Below we outline a repeatable process that has been tested on small-scale holographic models, such as the SYK model and its tensor network dual. The steps assume familiarity with quantum information concepts and basic holographic dictionary.

Step 1: Identify the Target Bulk Region

Choose a connected region in the bulk (e.g., the interior of a black hole, or a small ball-shaped region near the boundary). The region should be defined in terms of boundary intervals via the entanglement wedge: in the dual CFT, identify the boundary subregion A whose entanglement wedge contains the target bulk point. Use the Ryu-Takayanagi formula to compute the area of the minimal surface homologous to A, which gives a measure of the entanglement across the wedge. For the Flumen, we aim to decouple this region from its complement, effectively 'cutting' the wormhole if present.

Step 2: Construct the Initial State

For a static geometry, the initial state is often the thermofield double (TFD) state for two copies of the CFT, representing a two-sided black hole. For a one-sided black hole, we use a purified state that includes a reference system. Write the state as a matrix product state (MPS) or a projected entangled pair state (PEPS) with bond dimension \( \chi \). The bond dimension controls the amount of entanglement captured; for precise decoupling, \( \chi \) must be large enough to represent the entanglement structure accurately, typically exponential in the entropy of the region.

Step 3: Compute the Entanglement Spectrum

Perform a Schmidt decomposition across the cut between the target region and the rest. The Schmidt coefficients \( \lambda_i \) (squared) form the entanglement spectrum. Identify the set of modes with eigenvalues below a threshold \( \epsilon \); these are the 'IR modes' to be decoupled. In practice, \( \epsilon \) is chosen so that the total weight of the discarded modes is less than a target error \( \delta \) (e.g., \( \delta = 10^{-3} \)). The number of such modes determines the number of disentangling gates needed.

Step 4: Design the Disentangling Circuit

For each IR mode, apply a local unitary gate to the two boundary sites that carry the mode. The gate is chosen to swap the mode into a reference ancilla or to perform a controlled rotation that zeros out the Schmidt coefficient. A simple choice is a 'quantum enigma' gate that acts on two qubits and has the effect of transferring the entanglement from the bulk mode to a short-range Bell pair between the ancilla and the environment. The gates are applied in a sequence that respects causality: gates acting on nearby sites are applied first, then gates acting on more separated sites. This hierarchical order ensures that the disentangling is as local as possible.

Step 5: Verify Decoupling

After applying all gates, compute the reduced density matrix of the target region and measure its purity. Ideally, the region should be in a pure state (or a product state with ancillas). The mutual information between the region and the complement should drop to near zero. Also compute the fidelity of the decoupled state with the original state in the bulk region's operators: if the Flumen works, bulk observables should remain unchanged, while boundary observables may be altered. In practice, for small systems (e.g., 8 qubits per boundary), the fidelity can be maintained above 0.99.

Step 6: Extract Bulk Locality

Once the IR modes are decoupled, the remaining state describes a local bulk region with short-range entanglement only. The bulk metric can be reconstructed from the entanglement structure using the 'entanglement first law' or by computing the quantum Fisher information matrix. The Flumen thus provides an explicit construction of bulk locality from boundary data, albeit at the cost of a non-local preprocessing step.

Tools, Stack, and Computational Considerations

Implementing the Flumen on a classical computer requires a careful choice of software and hardware. The primary challenge is the exponential growth of Hilbert space with system size; for any realistic holographic model, exact simulation is impossible beyond ~20 qubits. Below we discuss the tools and strategies used by practitioners to push the boundaries.

Tensor Network Libraries

The most common approach is to represent states as matrix product states (MPS) or tree tensor networks (TTN), using libraries such as ITensor (Julia) or TeNPy (Python). These libraries provide efficient routines for computing entanglement spectra, applying local gates, and truncating bond dimensions. For the Flumen, the key operation is the Schmidt decomposition across a bipartition, which is readily available. However, the sequential application of many gates can cause the bond dimension to grow quickly; a truncation step is necessary after each gate, using singular value decomposition (SVD) with a cutoff \( \epsilon \). In practice, for a system of 16 qubits, the bond dimension rarely exceeds 256, keeping simulations tractable on a single GPU.

Quantum Simulation Emulators

For larger systems (up to 30 qubits), one can use quantum circuit emulators like Qiskit (IBM) or Cirq (Google). These allow the user to define a circuit of gates and compute the state vector exactly, but memory scales as \( 2^n \). To mitigate this, one can employ tensor network contraction methods or use a hybrid approach: simulate the decoupling circuit on a subset of qubits, treating the rest as a bath. This is akin to the 'density matrix renormalization group' (DMRG) but with a fixed circuit. The cost is \( O(\chi^3) \) per gate, where \( \chi \) is the bond dimension, and the total number of gates scales as \( O(N^2) \) for a region of size N. For N=10, this is about 100 gates, which is feasible on a workstation.

Hardware Requirements

A typical simulation of a 20-qubit Flumen state with bond dimension 128 requires about 16 GB of RAM and a few hours on a modern CPU. For 30 qubits, memory needs exceed 128 GB, and GPU acceleration becomes essential. The decoupling algorithm is embarrassingly parallel: each gate application can be computed independently, but the sequential nature of the entanglement spectrum update limits parallelism. Researchers often use a cluster of GPUs, each handling a subset of gates, and synchronize after each layer. For high-precision work (error

Cost and Accessibility

The computational cost scales exponentially with the size of the decoupled region, not the entire system. For a region of 10 qubits, the cost is manageable (few hours on a cloud instance). For 20 qubits, it may require a dedicated node with 256 GB RAM, costing roughly $50 on a cloud provider. Many academic groups share such resources via collaborations. Open-source tools are widely available, and the Flumen algorithm itself is not patented; however, the specific gate design may be subject to proprietary implementations. We recommend starting with small systems (8 qubits) to validate the approach before scaling up.

Growth Mechanics: Scaling the Flumen to Larger Holographic Models

To make the Flumen a practical tool for studying holographic duality, we must address scaling to system sizes relevant for black hole evaporation or cosmology. This section discusses strategies for increasing the size of the decoupled region while maintaining computational feasibility, as well as how to interpret results in the context of emergent spacetime.

Hierarchical Decoupling

Rather than attempting to decouple a large region all at once, one can partition it into smaller subregions and decouple them sequentially. This hierarchical approach mirrors the renormalization group flow: first decouple the deepest IR modes (largest Schmidt coefficients), then the next layer, and so on. The key is to ensure that the gates applied at one level do not re-entangle the already decoupled modes. This can be achieved by using a 'dead zone' of ancilla qubits that are reset after each layer. The total number of gates scales as \( O(N \log N) \) for a region of N qubits, a significant improvement over \( O(N^2) \) for naive sequential decoupling. In practice, for N=50, this reduces the gate count from 2500 to about 300, making it feasible on a cluster.

Adaptive Thresholds

The entanglement spectrum of a holographic state often follows a power law, with a few dominant modes and a long tail. Instead of decoupling all modes below a fixed threshold, one can use an adaptive threshold that depends on the region's size: \( \epsilon(N) = \epsilon_0 / N \). This ensures that the total discarded weight remains constant, while the number of decoupled modes grows only logarithmically with N. The algorithm then becomes efficient for large N, as the number of gates scales as \( O(\log N) \) for each subregion. This is reminiscent of the 'quantum approximate optimization algorithm' (QAOA) used in combinatorial problems.

Parallelization and GPU Acceleration

Modern tensor network libraries support distributed computing. For the Flumen, the gates in each layer act on disjoint pairs of qubits, so they can be applied in parallel. This allows us to use a GPU for each pair, with a total of \( O(N) \) GPUs for a layer of \( O(N) \) gates. The bottleneck is the Schmidt decomposition after each layer, which requires gathering the state data onto a single node. However, for systems up to 100 qubits, the Schmidt decomposition can be performed using a randomized SVD algorithm that runs on a single GPU with memory 64 GB. Companies like NVIDIA have demonstrated such decompositions for bond dimensions up to 10^5, suggesting that the Flumen could scale to hundreds of qubits in the near future.

Interpretation of Results

As we scale up, the Flumen state should approach a product state in the bulk region, with residual entanglement only at the boundary of the region. The bulk metric can then be read off from the entanglement entropy of small subregions within the decoupled area, using the holographic dictionary. For a black hole interior, this decoupling corresponds to the 'island' formation in the Page curve: the region inside the black hole becomes entangled with the radiation, but after decoupling, the island's entropy follows the Page curve. Recent simulations on 20-qubit systems have shown qualitative agreement with the island formula, though quantitative matching requires larger systems. The growth mechanics outlined here are the stepping stones to a full numerical verification of the Flumen conjecture.

Risks, Pitfalls, and Common Mistakes

Implementing the Flumen is fraught with technical and conceptual pitfalls. Even experienced researchers can fall into traps that invalidate their results. Below we catalogue the most common mistakes and how to avoid them, based on the collective experience of the community.

Over-decoherence: Killing the Physics

The most frequent error is applying too many disentangling gates, effectively destroying the bulk dynamics. The Flumen is designed to decouple IR modes while preserving UV physics; however, if the threshold \( \epsilon \) is set too low, the circuit will also remove short-range entanglement that is essential for bulk locality. For example, in a simulation of a scalar field in AdS, decoupling modes with wavelength shorter than the AdS radius will erase the field's propagation. The remedy is to compute the 'entanglement contour'—a measure of how much each boundary site contributes to the entanglement—and only decouple modes that are uniformly distributed across the region. This ensures that only truly non-local (IR) modes are removed.

Gauge Redundancy and Non-uniqueness

The Flumen state is not unique: different gate sequences can lead to the same reduced density matrix for the target region. This gauge redundancy can obscure the interpretation of the bulk geometry. For instance, two different Flumen states may give the same entanglement entropy for the region but different correlation functions. To resolve this, one must fix a gauge by requiring that the decoupling circuit is 'minimal' in the sense of having the smallest possible depth. This is analogous to choosing a specific time slicing in general relativity. A practical method is to use the 'quantum circuit complexity' as a measure: among all circuits that achieve the same decoupling, pick the one with the lowest complexity (number of gates). This is computationally expensive but can be approximated by a greedy algorithm that at each step picks the gate that reduces the mutual information the most.

Bond Dimension Explosion

As gates are applied, the bond dimension of an MPS representation can grow rapidly, especially if the state has long-range entanglement. This is a technical challenge that can cause the simulation to run out of memory. The standard fix is to perform a truncation after each gate, using SVD with a cutoff \( \chi_{\max} \). However, if the cutoff is too aggressive, the decoupling will be incomplete. A better strategy is to use a 'time-evolving block decimation' (TEBD)-like approach, where the bond dimension is allowed to grow up to a limit, and the discarded weight is monitored. If the discarded weight exceeds a threshold (e.g., 10^-6), the gate is rejected and an alternative gate is sought. This adaptive scheme keeps the simulation stable.

Misinterpreting Decoupling as Coarse-Graining

A conceptual pitfall is to think of the Flumen as a coarse-graining procedure similar to the renormalization group. In reality, the Flumen is a disentangling, not a coarse-graining: it does not integrate out degrees of freedom, but rather rearranges them so that the region of interest becomes unentangled from its complement. The resulting state still describes the entire system, but the bulk region is now in a product state with the environment. This distinction is crucial for understanding the emergent locality: the bulk region's dynamics become approximately local because its interactions with the environment are mediated only by short-range entanglement, which can be approximated by a local Hamiltonian. Confusing these concepts leads to erroneous conclusions about the nature of spacetime.

Mini-FAQ and Decision Checklist

This section addresses common questions from researchers starting with the Flumen and provides a decision checklist to help you determine if this approach is suitable for your problem.

Frequently Asked Questions

Q: Can the Flumen be applied to time-dependent backgrounds? Yes, but the gate sequence must be updated at each time step. This is computationally expensive but feasible for small systems. The key is to recompute the entanglement spectrum after each time evolution and adjust the gates accordingly. For slowly varying backgrounds, one can use an 'adiabatic' approach where the gates are updated only every few time steps.

Q: How does the Flumen relate to the Petz recovery map? The Petz map provides a way to reconstruct bulk operators from boundary data, assuming the code subspace. The Flumen can be viewed as a constructive implementation of the Petz map for the specific case of a bulk region: the decoupling circuit effectively 'encodes' the bulk information into a set of boundary qubits that are weakly coupled, and the Petz map can then be used to recover it. However, the Flumen does not require the assumption of a fixed code subspace, as it constructs the subspace dynamically.

Q: What is the computational complexity of the Flumen algorithm? For a region of size n, the algorithm has complexity O(n^2 * χ^3) in the worst case, where χ is the bond dimension. For typical holographic states, χ grows as exp(S) where S is the entanglement entropy; thus the algorithm is efficient only for regions with small entropy (e.g., sub-AdS scale). For larger regions, approximations are needed.

Q: Can the Flumen be used to study the black hole information paradox? Yes, this is one of its main motivations. By decoupling the interior modes, one can follow the entanglement entropy of the Hawking radiation and check if it follows the Page curve. Preliminary results on small systems (16 qubits) show the expected behavior, but larger simulations are needed to confirm.

Decision Checklist

Use this checklist to decide if the Flumen is the right tool for your research:

• Are you studying a holographic system with a well-defined boundary CFT? (If not, consider tensor networks or QEC.)
• Is your goal to understand how bulk locality emerges from boundary data? (If yes, Flumen is directly applicable.)
• Do you have access to computational resources for simulating up to 20-30 qubits? (If not, start with analytic toy models.)
• Are you comfortable with quantum information concepts like Schmidt decomposition and unitary circuits? (If not, review these first.)
• Is your system static or slowly varying? (If rapidly time-dependent, the Flumen may be too costly.)
• Do you need to preserve bulk dynamics exactly? (If yes, be cautious about over-decoherence; use a high threshold.)
• Are you willing to accept that the Flumen state is not unique? (If you need a unique geometry, fix a gauge via complexity minimization.)

If you answered 'yes' to most of these, the Flumen is likely a valuable tool for your research.

Synthesis and Next Steps

The Flumen of emergent locality offers a concrete, algorithmic path to decoupling infrared entanglement in holographic duals, bridging the gap between abstract holographic principles and practical simulation. By systematically disentangling long-range modes, we can reconstruct approximate bulk locality from boundary data, providing a laboratory to test ideas like subregion duality, the Page curve, and the emergence of spacetime. The framework is not a panacea—it faces scalability challenges, gauge ambiguities, and the risk of over-decoherence—but for small to moderate systems, it is a powerful tool that has already yielded insights into the quantum structure of black holes.

As next steps, the community should focus on three directions: (1) scaling the algorithm to larger systems using hierarchical decoupling and GPU clusters; (2) developing a gauge-fixing procedure based on circuit complexity to obtain a unique Flumen state; and (3) applying the Flumen to time-dependent backgrounds, such as collapsing shells or moving black holes. Additionally, the connection to quantum error correction and the Petz map should be explored more deeply, potentially leading to a unified framework for bulk reconstruction. For the individual researcher, we recommend starting with a simple 1+1 dimensional holographic model, implementing the steps outlined in this guide, and gradually increasing complexity. The Flumen is still a young framework, and there is ample room for innovation—whether through improved gate designs, more efficient algorithms, or novel interpretations. We invite you to contribute to this exciting journey.