jaxvacua.freezer.Freezer

jaxvacua.freezer.Freezer#

class Freezer(model)#

Bases: ABC

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

Given a full model with moduli \((z_{\text{heavy}}, z_{\text{light}}, \tau)\) and fluxes, the reduced EFT expresses the heavy moduli as functions of the light fields via their leading-order EOM:

(3)#\[z_{\text{heavy}} = z_{\text{heavy}}(z_{\text{light}}, \tau, \text{fluxes})\]

and provides the superpotential, its derivatives, etc. evaluated on this solution.

Subclasses must implement:

  • heavy_indices: which moduli are frozen out

  • solve_heavy: solve for heavy moduli given light fields

  • _real_light_to_full: convert real light-field coordinates to full array

Subclass contract – freezers are JAX pytrees

Every subclass is registered as a pytree automatically (__init_subclass__()), because the compiled reduced-EFT kernels take self as a traced argument. Instance attributes are therefore classified when the freezer crosses a jit boundary:

  • str / bool values travel as static auxiliary data;

  • arrays and registered pytrees (e.g. the bound model) become traced children;

  • anything else – notably ``int`` – becomes a traced child, which breaks it if the value is used as a Python trip count, a tuple index, or a branch condition. List such attributes in _pytree_static_keys.

Keep attributes to arrays, registered pytrees, and simple static scalars. Mutable scratch state (caches, open files) does not belong on a freezer that is passed to compiled code.

__init__(model)#

Initialise the Freezer base class.

Parameters:

model (Any) – A flux EFT model object providing superpotential, DW, DW_x, dDW_x, _convert_real_to_complex, and period data via lcs_tree.

Methods

DW_light(z_light, z_light_c, tau, tau_c, fluxes)

Covariant derivatives \(D_i W\) with respect to the light moduli, with heavy moduli on-shell.

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.

G_x_light(x_light, fluxes[, x_full, method])

Reduced Kähler metric of the light fields in the real interleaved basis, obtained by integrating out the heavy moduli at the level of the Kähler potential.

K_x_light(x_light, fluxes, **kwargs)

Real Kähler potential \(\mathrm{Re}\,K\) evaluated at the light-field coordinates, with the heavy moduli integrated out on-shell.

V_x_light(x_light, fluxes[, noscale])

Scalar potential \(V\) evaluated at the light-field coordinates, with heavy moduli on-shell.

__init__(model)

Initialise the Freezer base class.

dDW_x_light(x_light, fluxes, **kwargs)

Hessian \(\partial_{x^a}\partial_{x^b} W\) in real coordinates for the light moduli.

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.

ddV_x_light(x_light, fluxes[, noscale, ...])

Reduced Hessian of the scalar potential \(\partial_{\phi^\alpha}\partial_{\phi^\beta} V\) with respect to the real light-field coordinates, with the heavy moduli on-shell.

full_real_point(x_light, fluxes, **kwargs)

Full real coordinate vector with the heavy moduli on-shell -- the value accepted by the x_full argument of ddV_x_light() and light_mass_spectrum().

light_mass_spectrum(x_light, fluxes[, ...])

Mass spectrum of the light fields with the heavy moduli integrated out.

reconstruct_full_moduli(z_light, tau, ...)

Reconstruct the full moduli array by solving for the heavy moduli and inserting them at the correct positions.

solve_heavy(z_light, tau, fluxes, **kwargs)

Solve the leading-order EOM for the heavy moduli as functions of the light moduli, axio-dilaton, and fluxes.

superpotential(z_light, tau, fluxes, **kwargs)

Superpotential of the reduced theory.

Attributes

heavy_indices

Description: Indices of the heavy moduli within the full moduli array.

lcs_tree

Description: The bound model's period tree, model.lcs_tree.

light_indices

Description: Indices of the light moduli (complement of heavy_indices).

n_heavy

Description: Number of heavy moduli.

n_light

Description: Number of light moduli.
DW_light(z_light, z_light_c, tau, tau_c, fluxes, assume_conjugate=False, **kwargs)#

Covariant derivatives \(D_i W\) with respect to the light moduli, with heavy moduli on-shell.

Two heavy solves, and why that is the default

The holomorphic and antiholomorphic arguments are deliberately independent: the heavy moduli are solved once from \((z_{\rm light}, \tau)\) and once from \((\bar z_{\rm light}, \bar\tau)\). That is the whole purpose of the four-argument signature – it lets a caller differentiate holomorphically, \(\partial_\tau\) at fixed \(\bar\tau\), which is what a Kähler-covariant derivative \(D_\tau W = \partial_\tau W + (\partial_\tau K)W\) requires.

When you merely evaluate at \(\bar\tau = \overline{\tau}\), the second solve is redundant and assume_conjugate=True reuses \(\overline{z_{\rm full}}\) instead, halving the cost.

Warning

Treat assume_conjugate=True as evaluation only.

\(\bar\tau\) reaches the result by two routes: directly, as the tau_c argument of model.DW, and indirectly, through the conjugate heavy solve \(\overline{z_{\rm full}}(\bar z_{\rm light}, \bar\tau)\). Reusing \(\overline{z_{\rm full}}\) keeps the first and re-parents the second onto \((z_{\rm light}, \tau)\), so derivative correctness with respect to the conjugate arguments is not guaranteed in general. Since jnp.conj is itself differentiable, JAX will propagate through it and return something rather than raising, so an error of this kind would be silent.

Measured on the LCS reference PFV (n_light = 0, real \(\vec p\), linear reconstruction) the d/d tau_c derivatives of the two routes agree exactly – there, the \(\bar\tau\) dependence of \(D_\tau W\) happens to flow entirely through the direct argument. That is a property of this case, not a general guarantee: a reconstruction whose conjugate branch genuinely depends on \(\bar\tau\) (e.g. a \(z_{\rm cf}\) throat solve) has not been checked. Leave it False inside a grad/jacfwd/jacrev over the conjugate arguments unless you have verified your own case.

Parameters:

  • z_light (Array) – Light moduli values.

  • z_light_c (Array) – Conjugate light moduli values.

  • tau (complex) – Axio-dilaton.

  • tau_c (complex) – Conjugate axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • assume_conjugate (bool) – Reuse \(\overline{z_{\rm full}}\) instead of performing the second heavy solve. Valid only when z_light_c/tau_c really are the conjugates and no derivative is taken with respect to them – see the warning. Defaults to False (two independent solves).

Returns:

Array – \(D_i W\) for the light moduli and \(D_\tau W\).

Return type:

Array

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.

This is the analogue of model.DW_x but restricted to the light degrees of freedom.

Parameters:

  • x_light (Array) – Real variables for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

Returns:

Array – Real gradient restricted to light directions.

Return type:

Array

G_x_light(x_light, fluxes, x_full=None, method='pullback', **kwargs)#

Reduced Kähler metric of the light fields in the real interleaved basis, obtained by integrating out the heavy moduli at the level of the Kähler potential.

Details

The reduced metric is the mixed second derivative of the substituted Kähler potential \(K(z_{\rm heavy}^\ast(\phi), \phi)\), NOT the light submatrix of the full metric. The substitution couples the light moduli through the heavy solution, so the reduced metric carries chain-rule terms (e.g. complex-structure–dilaton mixing) absent from the bare bulk block.

Concretely, the real symmetric Hessian \(H_K = \partial_{\phi^\alpha}\partial_{\phi^\beta} \mathrm{Re}\,K\) of K_x_light() is taken by automatic differentiation, the complex Hermitian metric \(G_{A\bar B}\) is extracted via _G_from_real_hessian(), and the real metric is rebuilt with _kahler_metric_real_interleaved().

Two equivalent routes – method

"pullback" (default): the reduced metric is the pullback of the full Kähler metric along the on-shell tangent, \(G_{\rm eff} = J^T G_{\rm full} J\), with \(J = \partial x_{\rm full}/\partial\phi\) from _onshell_tangent(). This is exact whenever the heavy solve is holomorphic in the light fields – which F-flatness provides, since \(W\) is holomorphic, so \(z^\ast(\phi)\) is too and the mixed derivative \(\partial\bar\partial K\) picks up no second-derivative term. Cost: one metric evaluation plus one first-order tangent.

"autodiff": the original route, jax.hessian of the substituted K_x_light() straight through the heavy solve. Kept as the reference – it makes no holomorphy assumption – but for PFVEFT(mode="eom") it differentiates through a Newton iteration, which is ~5 orders of magnitude more expensive.

Measured equivalence, and its one caveat. The two routes were compared directly:

  • PFVEFT (LCS reference PFV, 2x2 reduced metric): relative 4.9e-08, masses agreeing to 8 significant figures.

  • ConifoldFreezer ("aule" coniLCS, n_light=4, 10x10 reduced metric) with apply_correction=False – i.e. a pure F-term z_cf solve, which is strictly holomorphic: relative 2.9e-16, machine precision, as the argument predicts exactly.

  • the same with apply_correction=True (the ConifoldFreezer default): relative 1.7e-07.

That last case is not exact, and the reason is physical: the Kähler-covariant z_cf correction depends on \(\bar z\) as well as \(z\), so the heavy solve is no longer strictly holomorphic and the second-derivative term no longer cancels identically. The residual is nine orders of magnitude larger than the holomorphic case, yet still far below the EFT’s own truncation error – so "pullback" remains the sensible default. If you need the assumption-free value (for a convergence study, or a deep throat where the correction is large), use method="autodiff".

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • x_full (Optional[Array]) – Full real point with the heavy moduli on-shell (see full_real_point()). Supplying it skips the heavy solve entirely; "autodiff" ignores it, since it must differentiate through that solve.

  • method (str) – "pullback" (default, first-order) or "autodiff" (the through-the-solve reference).

  • **kwargs – Forwarded to the heavy solve / K_x_light().

Returns:

  • Array – Reduced Kähler metric in the real interleaved basis, of shape

  • `` (2 * n_light + 2, 2 * n_light + 2)

Raises:

ValueError – If method is not one of {"pullback", "autodiff"}.

Return type:

Array

K_x_light(x_light, fluxes, **kwargs)#

Real Kähler potential \(\mathrm{Re}\,K\) evaluated at the light-field coordinates, with the heavy moduli integrated out on-shell.

Details

The heavy field is substituted at the level of the potential: the light real coordinates are mapped to the full point via _real_light_to_full() (heavy moduli on-shell), converted to complex moduli, and inserted into the model’s Kähler potential. Using the actual conjugate (rather than an independent \(\bar\phi\)) keeps the result a genuinely real scalar, so its real Hessian — the reduced Kähler metric of G_x_light() — is symmetric and the extracted metric Hermitian by construction.

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

Returns:

float – \(\mathrm{Re}\,K(z_{\rm heavy}^\ast(\phi), \phi)\).

Return type:

float

V_x_light(x_light, fluxes, noscale=True, **kwargs)#

Scalar potential \(V\) evaluated at the light-field coordinates, with heavy moduli on-shell.

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • noscale (bool) – If True, uses the no-scale scalar potential \(V = e^K K^{I\bar J} D_I W D_{\bar J}\bar W\). Defaults to True.

Returns:

float – Value of \(V\) with heavy moduli at their on-shell values.

Return type:

float

dDW_x_light(x_light, fluxes, **kwargs)#

Hessian \(\partial_{x^a}\partial_{x^b} W\) in real coordinates for the light moduli.

Parameters:

  • x_light (Array) – Real variables for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

Returns:

Array – Hessian restricted to light directions.

Return type:

Array

dV_x_light(x_light, fluxes, noscale=True, **kwargs)#

Gradient of the scalar potential \(\nabla_\phi V\) with respect to the real light-field coordinates, with heavy moduli on-shell.

Details

Let \(\phi^\alpha = (a^1, v^1, \ldots, a^{n_{\rm light}}, v^{n_{\rm light}}, c_0, s)\) denote the real light-field coordinates, where \(z^i = a^i + \mathrm{i}\,v^i\) and \(\tau = c_0 + \mathrm{i}\,s\). This function returns the restriction

(6)#\[\nabla_\phi V \big|_{\phi^\alpha} = \partial_{\phi^\alpha} V(x_{\rm full}(\phi))\]

where \(x_{\rm full}(\phi)\) substitutes the on-shell heavy moduli via _real_light_to_full().

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • noscale (bool) – If True, uses the no-scale scalar potential. Defaults to True.

Returns:

  • Array – Gradient \(\partial_{\phi^\alpha} V\), restricted to

  • light directions, of shape `` (2 * n_light + 2,)

Return type:

Array

ddV_x_light(x_light, fluxes, noscale=True, reduction='frozen', x_full=None, **kwargs)#

Reduced Hessian of the scalar potential \(\partial_{\phi^\alpha}\partial_{\phi^\beta} V\) with respect to the real light-field coordinates, with the heavy moduli on-shell.

Details

The real light-field coordinates are \(\phi^\alpha = (a^1, v^1, \ldots, a^{n_{\rm light}}, v^{n_{\rm light}}, c_0, s)\) (with \(z^i = a^i + \mathrm{i}\,v^i\) and \(\tau = c_0 + \mathrm{i}\,s\)). Four reduction schemes are provided via reduction:

  • "frozen" (default): the selection block \(J^T (\nabla\nabla V) J\), with the heavy moduli held at their on-shell values but WITHOUT the back-reaction of the light fields on the heavy solution.

  • "schur": the Schur complement on the heavy block,

    (7)#\[H_{\rm eff} = H_{\ell\ell} - H_{\ell h} H_{hh}^{-1} H_{h\ell}\, ,\]

    which integrates the heavy moduli out at their V-minimum (\(\partial_{z_{\rm heavy}} V = 0\), obtained by extremising the quadratic form over the heavy directions). This is the right reduction when a genuinely heavy modulus really is integrated out at its potential minimum (ConifoldFreezer); it is exact only where that heavy direction is on-shell, so pass x_full (the stored full point) — otherwise the heavy field is reconstructed from the analytic solve, which is on-shell only deep in the throat, and schur can return a spurious tachyon at moderate throats.

    Important

    For a PFVEFT the moduli are not at a V-minimum: they are slaved along the flat direction (\(\partial_z W = 0\)), which is not a V-valley. "schur" then computes a genuinely different reduction from the racetrack \(\tau\)-mass and lands a few \(\times\) off it (verified against a finite-difference reference and the racetrack). Use "tangent" / "autodiff" (the F-flat slaving) for a PFV mass; "schur" there is a V-minimum diagnostic, not the physical mass.

    Only the heavy block \(H_{hh}\) is inverted, so it is well conditioned at a genuine vacuum, but the back-reaction is a difference of large nearly cancelling terms once the heavy/light mass hierarchy approaches 1/eps (deep in a conifold throat); there it loses precision.

  • "autodiff": the Hessian of \(V(x_{\rm full}(\phi))\) differentiated directly through the on-shell heavy solve, so the back-reaction enters automatically via the chain rule. This builds a fresh jax.hessian trace on each call (the inner kernels are cached, the outer transform is not), so jit/loop accordingly for repeated use. Exact everywhere but the most expensive option.

  • "tangent": the same physical reduced Hessian as "autodiff" at a genuine vacuum, built from the first-order on-shell tangent \(J = \partial x_{\rm full}/\partial\phi\) (one jax.jacfwd of the heavy solve): \(H_{\rm eff} = J^T(\nabla\nabla V)J\). Avoiding the second-order jax.hessian makes it orders of magnitude cheaper (a warm call is ~instant). Unlike "schur" — which integrates the moduli out at their V-minimum — it follows the physical F-flat slaving (\(\partial_z W = 0\), the racetrack direction) and carries no large-cancellation precision loss. It differs from "frozen" only in that \(J\) is the true on-shell tangent (with the heavy back-reaction), not the constant leading-order one. Drops the \(O(\partial V)\) term, so it is exact only at a critical point — the recommended choice for masses at a vacuum.

Warning

reduction="frozen" omits the integrate-out back-reaction \(-H_{\ell h} H_{hh}^{-1} H_{h\ell}\), which can dominate (or flip the sign of) the lightest light mass in a conifold throat. It equals "autodiff" only for LCS in mode="ansatz" (the linear ansatz map, where \(\partial^2 x_{\rm full}/\partial\phi^2 = 0\)); in mode="eom" it keeps the constant ansatz tangent at the on-shell point, so on an exponentially small mass it can be \(O(10^2)\) off. For any vacuum mass prefer reduction="tangent" (fast + exact) or "autodiff" (robust off-shell); "schur" computes the V-minimum reduction (right for a genuinely heavy modulus, but off the racetrack mass for a PFV) and also loses precision when the heavy/light hierarchy is large. Note light_mass_spectrum() pairs the frozen Hessian with the substituted reduced metric, so its eigenvalues are a hybrid (a no-back-reaction Hessian against a with-back-reaction metric), not the naive frozen masses.

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • noscale (bool) – If True, uses the no-scale scalar potential. Defaults to True.

  • reduction (str) – Reduction scheme, one of {"frozen", "schur", "autodiff", "tangent"}. Defaults to "frozen" (the backwards-compatible leading-order block; note light_mass_spectrum() resolves its own, per-class default instead). For a mass at a vacuum "tangent" is the fast + exact choice; "schur" gives the V-minimum reduction (right for a genuinely heavy modulus, not for a PFV flat direction). Distinct from the mode keyword (forwarded via **kwargs to the heavy solve).

  • x_full (Optional[Array]) – Full real point at which to evaluate the Hessian for "frozen"/"schur" (e.g. the stored vacuum, with the heavy field on-shell). If None (default) the heavy field is reconstructed from the analytic solve via _real_light_to_full(). Ignored by "autodiff" (which differentiates through the solve).

Returns:

  • Array – Reduced Hessian restricted to light directions, of shape

  • `` (2 * n_light + 2, 2 * n_light + 2)

Return type:

Array

full_real_point(x_light, fluxes, **kwargs)#

Full real coordinate vector with the heavy moduli on-shell – the value accepted by the x_full argument of ddV_x_light() and light_mass_spectrum().

Why you want this

The heavy solve is by far the most expensive part of a reduced-EFT evaluation (for PFVEFT(mode="eom") it is a Newton iteration). Reconstruct the point once and pass it as x_full to evaluate several reductions – or a whole mass spectrum – at the same vacuum without repeating the solve. When you already have a certified vacuum (e.g. from a root find, or a stored jaxvacua.vacuum.Vacuum), pass that instead of reconstructing at all.

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • **kwargs – Forwarded to the heavy solve.

Returns:

Array – Full real coordinate vector of length 2*(h12+1).

Return type:

Array

abstract property heavy_indices: Tuple[int, ...]#

Description: Indices of the heavy moduli within the full moduli array.

Returns:

tuple[int, …] – The heavy-modulus indices.

property lcs_tree: Any#

Description: The bound model’s period tree, model.lcs_tree.

A delegating property rather than a stored attribute on purpose. Storing it would (i) duplicate the entire period/GV payload as a second set of traced children in every compiled kernel (freezers are registered pytrees, see _register_freezer_pytree()), and (ii) freeze a snapshot of a mutable object, so an in-place lcs_tree edit would leave the freezer disagreeing with its own model.

Returns:

Any – The model’s lcs_tree.

property light_indices: Tuple[int, ...]#

Description: Indices of the light moduli (complement of heavy_indices).

Returns:

tuple[int, …] – The light-modulus indices.

light_mass_spectrum(x_light, fluxes, reduction=None, noscale=True, dw_tol=0.0001, rel_tol=1e-08, eig_backend='scipy', warn_dynamic_range=100000000000000.0, x_full=None, **kwargs)#

Mass spectrum of the light fields with the heavy moduli integrated out.

Solves the generalised eigenvalue problem \(H_{\rm eff}\,v = \lambda\,K_{\rm eff}\,v\), where \(H_{\rm eff}\) is the reduced Hessian (ddV_x_light()) and \(K_{\rm eff}\) the reduced Kähler metric (G_x_light()). Routing the masses through a generalised eigenproblem in the real basis avoids the ill-conditioning and basis artefacts of the full mass_matrix().

Details

The light masses follow the supergravity real-field normalisation \(\phi = (a + \mathrm{i} b)/\sqrt2\), so \(m^2 = \tfrac12\,\lambda\).

On-shell evaluation and screening (two modes). The reduced Hessian (schur/frozen) equals the Hessian of the reduced potential only where the heavy direction is on-shell, so the screen and the recommended usage depend on which heavy solution you trust:

  • Analytic reduced EFT (x_full=None, the default): the heavy field is reconstructed from the analytic compute_zcf() solve, which IS its on-shell value in the EFT. The vacuum condition is then the light F-terms, so the point is screened on max|DW_x_light| <= dw_tol. The full residual max|DW_x| (heavy component included) is the controlled EFT truncation: it is reported as dw_residual but does NOT reject the point, so a legitimate moderate-throat vacuum is no longer spuriously flagged.

  • Certified numerical vacuum (x_full given): evaluate the Hessian at a stored full vacuum and screen the full residual max|DW_x(x_full)| <= dw_tol – the heavy direction must itself be on-shell, which also catches a wrong heavy solve / wrong apply_correction.

In both modes dw_residual is the full residual, and an off-shell point returns an empty spectrum with reason="off-shell". The reduced metric always uses the analytic substituted potential (it differentiates through the solve). For coniLCS the apply_correction=True z_cf-solve default (set by ConifoldFreezer) gives a usable analytic seed; it belongs to the z_cf solve and is unrelated to reduction="autodiff".

Note

Eager host-side helper (NumPy/SciPy at the eigensolve): not jit/vmap-able; batch over vacua with a Python loop.

Parameters:

  • x_light (Array) – Real coordinates for light moduli and axio-dilaton.

  • fluxes (Array) – Full flux vector.

  • reduction (Optional[str]) – Hessian reduction scheme, one of {"frozen", "schur", "autodiff", "tangent"}. Defaults to None, which resolves to _default_light_reduction – "schur" for the base class / ConifoldFreezer (the V-minimum Schur complement, correct for a genuinely heavy modulus integrated out at its potential minimum) and "tangent" for PFVEFT (the F-flat racetrack mass; "schur" there gives the different V-minimum mass – see ddV_x_light()). "frozen" omits the back-reaction (and is paired with the substituted reduced metric, so its eigenvalues are a hybrid); it is diagnostic only. Orthogonal to the z_cf-solve mode forwarded via **kwargs.

  • noscale (bool) – If True, uses the no-scale scalar potential. Defaults to True.

  • dw_tol (float) – On-shell tolerance on the F-term residual – the light max|DW_x_light| when x_full=None (analytic EFT), or the full max|DW_x(x_full)| when x_full is given. Defaults to 1e-4.

  • rel_tol (float) – Relative tolerance for the stability flag and the flat-direction floor of the dynamic-range diagnostic. Defaults to 1e-8.

  • eig_backend (str) – "scipy" (default, generalised scipy.linalg.eigh; tolerates an indefinite H_eff but requires a positive-definite K_eff) or "jax" (Cholesky whitening, also requires a positive-definite K_eff). Defaults to "scipy".

  • warn_dynamic_range (float) – Warn when the reduced spectrum’s dynamic range max|m^2|/min|m^2| (flat directions excluded) exceeds this – a large range means the lightest masses are precision-limited relative to the heaviest (float64 1/eps ~ 4.5e15). Defaults to 1e14.

  • x_full (Optional[Array]) – Full real point (the stored vacuum, heavy field on-shell) at which to evaluate the reduced Hessian and the on-shell screen. If None the heavy field is reconstructed from the analytic solve via **kwargs. Note reduction="autodiff" IGNORES x_full for the Hessian (it always differentiates through the analytic heavy solve); only the on-shell screen and the reduced metric use x_full in that case. Pass reduction="schur" to evaluate the masses at a stored x_full.

Returns:

LightSpectrum – The reduced spectrum and stability diagnostics.

Return type:

LightSpectrum

property n_heavy: int#

Description: Number of heavy moduli.

Returns:

int – The number of heavy moduli.

property n_light: int#

Description: Number of light moduli.

Returns:

int – The number of light moduli.

reconstruct_full_moduli(z_light, tau, fluxes, **kwargs)#

Reconstruct the full moduli array by solving for the heavy moduli and inserting them at the correct positions.

Parameters:

  • z_light (Array) – Light moduli values.

  • tau (complex) – Axio-dilaton value.

  • fluxes (Array) – Full flux vector.

Returns:

Array – Full moduli array of length h12.

Return type:

Array

abstractmethod solve_heavy(z_light, tau, fluxes, **kwargs)#

Solve the leading-order EOM for the heavy moduli as functions of the light moduli, axio-dilaton, and fluxes.

Parameters:

  • z_light (Array) – Values of the light complex structure moduli.

  • tau (complex) – Axio-dilaton value.

  • fluxes (Array) – Full flux vector.

Returns:

Array – Values of the heavy moduli.

Return type:

Array

superpotential(z_light, tau, fluxes, **kwargs)#

Superpotential of the reduced theory.

Parameters:

  • z_light (Array) – Light moduli values.

  • tau (complex) – Axio-dilaton.

  • fluxes (Array) – Full flux vector.

Returns:

complex – \(W(z_{\text{light}}, \tau)\) with heavy moduli on-shell.

Return type:

complex