jaxvacua.freezer

Reduced EFT interfaces for integrating out heavy moduli.

Purpose

Provide abstractions for solving heavy-field equations of motion and evaluating a reduced flux EFT on the remaining light fields.

Main public API

• Freezer: abstract base class defining the reduced-EFT interface, including heavy/light index bookkeeping, reconstruction and light-field derivatives.

• ConifoldFreezer: concrete implementation for freezing the conifold modulus z_cf in coniLCS models.

Design notes

Freezers wrap an existing flux model. They do not own the underlying geometry; instead they solve heavy fields as functions of light moduli, axio-dilaton and fluxes, then reuse the model’s superpotential and derivative methods on the reconstructed full field point.

When to use this module

Use a freezer after constructing a full flux effective theory, when one or more complex-structure fields are treated as heavy and should be solved away before scanning the remaining light directions. Freezer provides the base reduced-EFT interface; ConifoldFreezer is the specialised implementation for integrating out a conifold modulus with the coniLCS z_cf equation of motion.

Reduced-EFT workflow

1. Wrap the full model with ConifoldFreezer and specify the conifold modulus through conifold_index.

2. Call solve_heavy to determine the heavy modulus for fixed light moduli, axio-dilaton, and fluxes.

3. Use reconstruct_full_moduli when a full moduli vector is needed again, for example before evaluating quantities defined on the original model.

4. Evaluate reduced quantities with superpotential, DW_light, DW_x_light, dDW_x_light, V_x_light, dV_x_light, and ddV_x_light.

Index conventions

heavy_indices names the frozen complex-structure moduli and light_indices is its complement. The counters n_heavy and n_light refer to complex moduli, while real light-field vectors used by the *_x_light methods contain real and imaginary parts of the light moduli plus the real and imaginary parts of tau.

jaxvacua.freezer — heavy/light reduction

Full EFT inputs

full model

FluxEFT data for $W$, $D_IW$, $V$ and derivatives

flux vector

integral $(F_3,H_3)$ data held fixed during reduction

light fields

$z_{\rm light}$ and $\tau$, or real vector $x_{\rm light}$

↓

Index split

heavy_indices

moduli solved away analytically
n_heavy

light_indices

remaining moduli kept in the reduced EFT
n_light

↓

Heavy-field equation of motion

solve_heavy

For ConifoldFreezer, compute $z_{\rm cf}$ from compute_zcf / zcf_handling
optional Kähler-covariant correction included through the coniLCS solver

↓

Reduced evaluation path

reconstruct_full_moduli

insert $z_{\rm heavy}(z_{\rm light},\tau,\mathrm{flux})$ back into the full vector

light-field EFT

superpotential, DW_light, DW_x_light, V_x_light, derivatives

Output:  a lower-dimensional Newton or analysis problem on $2\,n_{\rm light}+2$ real fields, with heavy moduli solved consistently at each evaluation.

Freezer base class

Freezer(model)

Abstract base class for a reduced effective field theory obtained by integrating out a set of heavy moduli.

Light-field EFT interface

Freezer.solve_heavy(z_light, tau, fluxes, ...)	Solve the leading-order EOM for the heavy moduli as functions of the light moduli, axio-dilaton, and fluxes.
Freezer.reconstruct_full_moduli(z_light, ...)	Reconstruct the full moduli array by solving for the heavy moduli and inserting them at the correct positions.
Freezer.superpotential(z_light, tau, fluxes, ...)	Superpotential of the reduced theory.
Freezer.DW_light(z_light, z_light_c, tau, ...)	Covariant derivatives \(D_i W\) with respect to the light moduli, with heavy moduli on-shell.
Freezer.DW_x_light(x_light, fluxes, **kwargs)	Gradient of the superpotential \(\partial_{x^a} W\) in real coordinates for the light moduli, with heavy moduli on-shell.
Freezer.dDW_x_light(x_light, fluxes, **kwargs)	Hessian \(\partial_{x^a}\partial_{x^b} W\) in real coordinates for the light moduli.
Freezer.V_x_light(x_light, fluxes[, noscale])	Scalar potential \(V\) evaluated at the light-field coordinates, with heavy moduli on-shell.
Freezer.dV_x_light(x_light, fluxes[, noscale])	Gradient of the scalar potential \(\nabla_\phi V\) with respect to the real light-field coordinates, with heavy moduli on-shell.
Freezer.ddV_x_light(x_light, fluxes[, noscale])	Hessian of the scalar potential \(\partial_{\phi^\alpha}\partial_{\phi^\beta} V\) with respect to the real light-field coordinates, with heavy moduli on-shell.

Conifold freezer

ConifoldFreezer(model[, conifold_index])

Integrates out the conifold modulus \(z_{\text{cf}}\) (index 0) in coniLCS models.

Conifold EOM

ConifoldFreezer.solve_heavy(z_light, tau, fluxes)	Solve for \(z_{\text{cf}}\) from its leading-order EOM by delegating to jaxvacua.conifold.zcf_solver.compute_zcf() (the unified complex-coord dispatcher attached to the model).
ConifoldFreezer.reconstruct_full_moduli(...)	Reconstruct the full modulus vector from the light (bulk) moduli with the conifold modulus on-shell. Aligned: index scatter (base class). General: \(z_{\rm full} = z_{\rm cf}\,e_q + \text{bulk\_embedding}\,z_{\rm light}\).