Sparse Modular Forms, Lattices, and Codes
summary
The gist
Sparse modular forms, lattices, and codes are investigated to find sparseness conditions motivated by sparseness requirements for holographic CFTs <ref:2511.13816#pg2>.
In short
The research investigates sparse modular forms and lattices derived from codes to meet sparseness conditions required for holographic CFTs. The study shows that certain families of modular forms are sparse, and lattices constructed from self-dual Reed-Muller codes exhibit theta3-sparseness, providing evidence that these constructions satisfy the necessary constraints for holographic theories.
Key concepts
- Sparse Modular Forms
- These are special functions within modular forms where a specific limit involving their Fourier expansion (starting with '1 + 0q + 0q2') goes to zero. This property is linked to physical requirements in holographic CFTs, suggesting they represent systems with limited state spectra.
- Lattices from Codes
- This involves creating mathematical lattices using binary linear codes, specifically Construction A. The study examines the 'free energy' of these lattices as the code length increases. A key goal is to determine if this free energy satisfies a specific limit condition indicating sparseness.
- Theta3-Sparsity
- This is a specific type of sparseness condition applied to lattices, often related to bounding multiplicities in weight enumerators. The paper tests whether lattices derived from Reed-Muller codes satisfy this condition by analyzing the growth rate of their weights, suggesting they are sparse enough for holographic applications.
Terminology used across episodes
This episode discusses
- Sparse Modular Forms, Lattices, and Codes · Paper Radio
- Three-Dimensional Gravity Revisited
- Universal Spectrum of 2d Conformal Field Theory in the Large c Limit
- A universal inequality on the unitary 2D CFT partition function
- Comments on the holographic description of Narain theories
- Quantum stabilizer codes, lattices, and CFTs
- Quantum Codes, CFTs, and Defects
- Narain CFTs and error-correcting codes on finite fields
- Narain CFTs and Quantum Codes at Higher Genus
- Narain CFTs from qudit stabilizer codes
- Fermionic CFTs from classical codes over finite fields
- Narain CFTs from nonbinary stabilizer codes
- Holographic description of Narain CFTs and their code-based ensembles
- Unifying error-correcting code/Narain CFT correspondences via lattices over integers of cyclotomic fields
- Optimal Narain CFTs from Codes
- An upper bound on q norms of noisy functions
The paper
Sparse Modular Forms, Lattices, and Codes · Read on arXiv
Christoph A. Kellera, Ashley Winter Roberts
University of Arizona · Institut für Theoretische Physik, ETH Zurich
Transcript
Introduction to the show: ident: High Energy Physics: Theory. The day in high-energy theory: gravity, strings, fields and the questions left open.
Kai: We're looking at the paper: "Sparse Modular Forms, Lattices, and Codes".
Mira: Here's the gist of the paper. Sparse modular forms, lattices, and codes are investigated to find sparseness conditions motivated by sparseness requirements for holographic CFTs <ref:2511.13816#pg2>.
Kai: The paper constructs families of sparse modular forms and investigates lattices derived from codes, providing evidence that certain constructions are sparse in a specific sense <ref:2511.13816#pg5>.
Mira: Holographic CFTs describing gravity on anti-de Sitter spaces need to satisfy sparseness conditions, such as the light spectrum not containing too many states <ref:2511.13816#pg3>.
Kai: This is necessary for a large N or large central charge limit to exist <ref:2511.13816#pg3>.
Title and authors: Kai: So we're looking at this paper called "Sparse Modular Forms, Lattices, and Codes". It seems they're digging into how to find sparseness conditions for holographic conformal field theories.
Mira: Exactly. The core idea here is that these conditions are needed when you're dealing with gravity on anti-de Sitter spaces. Specifically, the paper looks at modular forms, lattices, and codes to see if we can build things that meet these sparseness requirements.
Lev: From an engineering standpoint, the interest is in finding concrete examples of how these mathematical objects behave when their size or dimension goes to infinity. It’s about constructing something that stays sparse even as it gets bigger.
Kai: Right. They construct families of sparse modular forms, like those Eisenstein series E2k tau, and then they look at lattices coming from codes to see if those also exhibit this sparseness in a specific sense.
Mira: That's the main thrust of the paper. They introduce a definition for sparseness related to the limit behavior of the free energy as you increase n. For modular forms, it means that after scaling by n, you get zero for all values greater than one.
Lev: And they also look at extremal modular forms, which they define separately where the limit of their free energy is zero when the scaling factor y is greater than point zero point seven two eight eight nine three. That's a specific threshold they found for that behavior.
Kai: Moving on to the lattices, they focus on Construction A lattices, defined as one over square root two times C plus two Z times n, where C is a binary linear code. They introduce a generalization of sparseness for these lattices based on the limit of their free energy f as n goes to infinity.
Mira: That limit condition they propose is that this free energy must approach the logarithm of theta three evaluated at i y for all values of y greater than one. That's a very precise way to test if the lattice is sparse in this context, and it’s a condition that guarantees similar behavior for entropy growth as the original sparseness condition.
Title and authors: Lev: And they test this using self-dual Reed-Muller codes, which are constructed from something called RM((m minus one)/two m) <ref:2511.13816#pg2>. The analysis suggests these codes are theta three sparse based on bounds on their weight enumerator multiplicities A k for low weights.
Kai: So what this means for us is that lattices built from these self-dual Reed-Muller codes are candidates for the sparse lattices needed in holographic CFTs. It’s evidence that certain constructions actually behave the way we need them to in this physics context, even if a full proof of saturation isn't established yet.
Mira: It points toward a specific type of structure—these codes—that naturally satisfy the required sparseness properties for these theories, which is something they noted earlier when discussing how Narain constructions don't always satisfy the original condition.
Lev: For real hardware, if we were building an error-correction scheme based on these lattices, we’d need to check if this convergence to the theta three limit happens fast enough when n is large, because that dictates the complexity of the code.
Kai: So they also suggest some improvements for finding these sparse modular forms. The idea is to automate the discovery process by building algorithms that construct extremal modular forms based on their Fourier expansion starting with one plus zero q plus zero q two.
Mira: That expansion is a strong starting point because it directly relates to the sparseness condition they are studying, and then you use coefficient estimates from bounds in reference twelve to verify if the resulting form actually meets those criteria.
Lev: That’s clever because it moves away from just checking limits and towards a constructive method for finding these sparse forms, which is much more useful for actual computation.
Kai: And for the lattices, they suggest an automated way to check Construction A lattices by evaluating the limit of their free energy directly as n goes to infinity. That lets the AI determine if it’s theta three sparse by checking if that specific limit equals the logarithm of theta three evaluated at i y for all values greater than one.
Title and authors: Mira: That gives us a clear, computational test for that generalized sparseness condition they introduced, which is a big step because before this, it was more about theoretical limits.
Lev: If we can automate that check on real code lattices, it means we could rapidly screen many possible constructions to find the ones most promising for actual application in quantum gravity models.
Kai: So to wrap up the Sparse Modular Forms, Lattices, and Codes paper, they show concrete families of forms and specific code lattices that satisfy the necessary sparseness conditions for holographic CFTs. It provides evidence that these mathematical tools can be used to construct the right kind of objects for this physics.
Mira: It really solidifies the idea that we need to think about sparseness conditions in a new way when we look at theories like Narain constructions, and this paper gives us a direction on what those sparse lattices might actually look like.
Lev: For us, it’s showing that the theoretical requirements translate into something concrete—a specific lattice structure derived from Reed-Muller codes—that has mathematical backing through weight enumerator analysis.
Kai: Yeah, so they've given us a few families of forms and a concrete class of lattices that should be sparse in the way we need them to be for these holographic CFTs. It’s definitely something worth looking at for building models.
Mira: It does give us some new ideas on how to search for those sparse modular forms, which is useful because finding those explicit examples is still a challenge.
Lev: We just need to make sure that when we move these constructions from the math paper to actual hardware, the overhead doesn't kill the efficiency gain we see here.
Kai: Right, so they’ve given us a few families of forms and a concrete class of lattices that should be sparse in the way we need them to be for these holographic CFTs. It’s definitely something worth looking at for building models.
The paper's summary: Kai: So, to wrap up this first bit, these authors are showing us how to find things that are sparse in these modular forms and lattices because we need them for holographic theories describing gravity on anti-de Sitter spaces.
Mira: Right. The big summary is they construct specific families of modular forms that have this sparseness property and then they build lattices using error-correcting codes to see if those lattices also have that required sparseness behavior, which they define as a limit condition on their free energy.
Lev: What that means for us is it’s about finding concrete examples—not just abstract math—that meet the sparseness criteria needed for things like large N limits in holographic CFTs.
Kai: They show that the lattices built from self-dual Reed-Muller codes are actually theta three sparse, which is strong evidence that these code constructions work for these specific physics requirements.
Mira: It really grounds this in something physical, connecting the abstract properties of modular forms and codes to the thermodynamic behavior we need for gravity models.
Lev: If we’re building hardware or error correction schemes based on these lattices, knowing they hit that theta three limit as n goes to infinity is a huge check on whether the complexity stays manageable.
Kai: It suggests a pathway: use these codes and modular forms as blueprints to construct the right kind of mathematical objects for our physics models.
Mira: And the authors are also proposing some actual methods, like using specific Fourier expansions of those modular forms to help us discover them automatically.
Lev: That’s useful because it moves this from just proving something exists to actually building a system that could generate these sparse structures efficiently.
Kai: So what we’re looking at now is how the authors are proposing algorithms to find these sparse modular forms and how they plan to test those lattice constructions computationally.
The paper's improvements: Tom: So, we’re talking about how these authors are suggesting ways to actually make this research more practical and easier to do.
Kai: It sounds like they want to automate the process of finding those sparse modular forms, which is a big deal because manually searching through all those possibilities is just not feasible.
Mira: They propose using algorithms that construct extremal modular forms starting with a specific Fourier expansion, you know, something like one plus zero q plus zero q two.
Lev: That’s smart because if you start the construction from that known structure, you can then use coefficient estimates from bounds in reference twelve to quickly verify if the resulting form actually meets the sparseness criteria.
Kai: So it’s shifting the focus from just proving something works to building a system that constructs those sparse forms on demand.
Mira: Exactly. And for the lattices, they suggest an automated way to check Construction A lattices by directly evaluating their free energy limit as n goes to infinity.
Lev: That means the AI could rapidly screen many code-derived lattices and instantly tell you if it’s theta three sparse by checking if that limit equals the logarithm of theta three evaluated at i y for all values greater than one.
Kai: So we’re moving toward a workflow where we can test these lattice constructions much faster than before, which is crucial when dealing with massive code sizes.
Mira: It also implies that for the Reed-Muller codes they analyzed, this weight enumerator property should give us strong evidence for theta three sparseness, even if they didn't prove it totally saturated yet.
Lev: That’s a good caveat to keep in mind: the bounds on low weight multiplicities are what suggest it’s sparse, but the authors admit they haven't done the full proof of saturation yet.
Kai: It shows that we can use existing tools, like weight enumerator bounds, to get very strong evidence without needing to solve every single technical detail immediately.
Mira: And this whole set of improvements points toward a future where we can systematically generate and test these sparse structures in the context of holographic theories.
Lev: It’s about making the construction pipeline robust enough to handle the scale that real quantum gravity simulations will eventually reach, which is something I think is pretty important for us right now.
Conclusion: Kai: So we’re wrapping up this look at "Sparse Modular Forms, Lattices, and Codes." The main point is that these authors found families of modular forms and lattices from codes that satisfy the sparseness conditions required for holographic CFTs.
Mira: Right. It shows us how these mathematical objects can be engineered to have the right kind of structure when you are looking at gravity in anti-de Sitter space.
Lev: For me, what’s interesting is that they provide concrete examples—specifically those lattices from self-dual Reed-Muller codes—that have this required theta three sparseness property.
Kai: That’s a lot of evidence that these code constructions can actually be used to build the right kind of structures for these holographic models.
Mira: The implication is that we have a new toolbox for constructing interesting lattices and forms, moving beyond just abstract theory to something with concrete mathematical backing.
Lev: If we think about running this on real hardware, knowing that these lattices converge to the theta three limit as n goes to infinity gives us a lot of confidence in the stability of those constructions at large scales.
Kai: It definitely suggests that the next step is taking these constructions and seeing what else they can do with them in actual simulations.
Mira: And they’ve also given us some constructive ideas, like using specific Fourier expansions to find these sparse modular forms automatically, which is a much more efficient way to discover them.
Lev: That’s useful because it moves this from just checking limits and hoping for the best to actually building a system that can generate these sparse structures efficiently.
Kai: So we’ve seen how they connect the theory of modular forms and coding theory to the physical requirements of holographic gravity.
Mira: It really solidifies the idea that there are deep connections between different mathematical fields when you’re trying to model complex physical systems.
Lev: It shows that we can use these codes not just for error correction, but as a way to build the specific geometric and algebraic structures needed for our physics models.
Kai: That's what we get from this paper on "Sparse Modular Forms, Lattices, and Codes."
Mira: It gives us new ways to look at the landscape of possible mathematical constructions in this area.
Lev: It sets a clear benchmark for what a sparse lattice should look like when you’re trying to build something scalable.
More episodes
- 2606.30117-Gravitational Duals from Equations of State II: Large Hierarchies and False Vacua
- Daily Summary for 2026-11-19
- 2603.06575-An ode to instantons
- 2607.09594-Massless fermionic current of Schwinger pairs in 3D de Sitter spacetime
- 2508.13283-Algebraic traversable wormholes
- 2509.07838-Multi-Centered Black Hole Index from a Superconformal Quiver Index
- 2512.16596-Trace anomaly for a conformal 2D vector field model
- 2605.03155-Flat Space Physics from AdS Actions
- 2606.02707-Gravitational index, black hole saddle degeneracy, and one-form symmetry
- 2606.24008-General Lagrangian formulations for mixed-antisymmetric tensor fields on flat backgrounds