Potentials

potentials

Potential functions for scalar field theory.

This module defines various potential functions \(V(\phi)\) and uses JAX's automatic differentiation to compute derivatives \(\frac{\partial V}{\partial \phi}\).

The ScalarPotential class provides a unified interface that:

1. Encapsulates potential parameters for hashability (enables JIT caching)
2. Provides autodiff-derived force \(F = -\frac{\partial V}{\partial \phi}\) automatically
3. Supports both real and complex fields via Wirtinger derivatives

ScalarPotential(name, params) dataclass

Unified potential representation with autodiff-derived forces.

This class encapsulates a potential function \(V(\phi)\) along with its parameters, providing automatic computation of forces via JAX autodiff. The frozen dataclass ensures hashability, enabling efficient JIT compilation caching.

Attributes:

Name	Type	Description
name	str	Identifier for the potential type (e.g., "quadratic", "quartic")
params	tuple	Tuple of parameters (must be hashable for caching)

Example

V = ScalarPotential.quartic(m=1.0, lambda_=0.1)
energy_density = V(field)            # V(phi) at each point
total_energy = V.total_energy(field) # sum of V(phi)
force = V.force(field)               # F = -dV/dphi (autodiff)

__call__(field)

Evaluate potential energy density \(V(\phi)\) at each lattice point.

Parameters:

Name	Type	Description	Default
field	Array	Scalar field configuration (real or complex)	required

Returns:

Type	Description
Array	Potential energy density array (same shape as field)

Source code in jaxlatt/core/potentials.py

def __call__(self, field: Array) -> Array:
    """
    Evaluate potential energy density $V(\\phi)$ at each lattice point.

    Args:
        field: Scalar field configuration (real or complex)

    Returns:
        Potential energy density array (same shape as field)
    """
    return _get_potential_fn(self)(field)

total_energy(field)

Compute total potential energy \(\sum V(\phi)\).

Parameters:

Name	Type	Description	Default
field	Array	Scalar field configuration	required

Returns:

Type	Description
Array	Total potential energy (scalar)

Source code in jaxlatt/core/potentials.py

def total_energy(self, field: Array) -> Array:
    """
    Compute total potential energy $\\sum V(\\phi)$.

    Args:
        field: Scalar field configuration

    Returns:
        Total potential energy (scalar)
    """
    return jnp.sum(self(field)).real

force(field)

Compute force \(F = -dV/d\phi\) using autodiff.

For complex fields, computes the Wirtinger derivative \(-dV/d\phi^*\).

Parameters:

Name	Type	Description	Default
field	Array	Scalar field configuration	required

Returns:

Type	Description
Array	Force array (same shape as field)

Source code in jaxlatt/core/potentials.py

def force(self, field: Array) -> Array:
    """
    Compute force $F = -dV/d\\phi$ using autodiff.

    For complex fields, computes the Wirtinger derivative $-dV/d\\phi^*$.

    Args:
        field: Scalar field configuration

    Returns:
        Force array (same shape as field)
    """
    return _get_cached_force(self)(field)

quadratic(m=1.0) staticmethod

Create quadratic potential \(V(\phi) = \frac{1}{2} m^2 |\phi|^2\).

This is the simplest non-trivial potential, commonly used in chaotic inflation models and free field theory.

Parameters:

Name	Type	Description	Default
m	float	Mass parameter	1.0

Returns:

Type	Description
ScalarPotential	ScalarPotential instance

Source code in jaxlatt/core/potentials.py

@staticmethod
def quadratic(m: float = 1.0) -> "ScalarPotential":
    """
    Create quadratic potential $V(\\phi) = \\frac{1}{2} m^2 |\\phi|^2$.

    This is the simplest non-trivial potential, commonly used in
    chaotic inflation models and free field theory.

    Args:
        m: Mass parameter

    Returns:
        `ScalarPotential` instance
    """
    return ScalarPotential(name="quadratic", params=(m,))

quartic(m, lambda_) staticmethod

Create quartic potential \(V(\phi) = \frac{1}{2} m^2 |\phi|^2 + \frac{1}{4} \lambda |\phi|^4\).

Standard scalar field potential with mass term and self-interaction. Used in Higgs-like models and preheating studies.

Parameters:

Name	Type	Description	Default
m	float	Mass parameter	required
lambda_	float	Quartic self-coupling	required

Returns:

Type	Description
ScalarPotential	ScalarPotential instance

Source code in jaxlatt/core/potentials.py

@staticmethod
def quartic(m: float, lambda_: float) -> "ScalarPotential":
    """
    Create quartic potential $V(\\phi) = \\frac{1}{2} m^2 |\\phi|^2 + \\frac{1}{4} \\lambda |\\phi|^4$.

    Standard scalar field potential with mass term and self-interaction.
    Used in Higgs-like models and preheating studies.

    Args:
        m: Mass parameter
        lambda_: Quartic self-coupling

    Returns:
        `ScalarPotential` instance
    """
    return ScalarPotential(name="quartic", params=(m, lambda_))

double_well(mu2=1.0, lam=1.0) staticmethod

Create double-well potential \(V(\phi) = -\frac{1}{2} \mu^2 \phi^2 + \frac{1}{4} \lambda \phi^4\).

Has minima at \(\phi = \pm\sqrt{\mu^2/\lambda}\), used for symmetry breaking studies.

Parameters:

Name	Type	Description	Default
mu2	float	Negative mass squared coefficient	1.0
lam	float	Quartic coupling	1.0

Returns:

Type	Description
ScalarPotential	ScalarPotential instance

Source code in jaxlatt/core/potentials.py

@staticmethod
def double_well(mu2: float = 1.0, lam: float = 1.0) -> "ScalarPotential":
    """
    Create double-well potential $V(\\phi) = -\\frac{1}{2} \\mu^2 \\phi^2 + \\frac{1}{4} \\lambda \\phi^4$.

    Has minima at $\\phi = \\pm\\sqrt{\\mu^2/\\lambda}$, used for symmetry breaking studies.

    Args:
        mu2: Negative mass squared coefficient
        lam: Quartic coupling

    Returns:
        `ScalarPotential` instance
    """
    return ScalarPotential(name="double_well", params=(mu2, lam))

mexican_hat(lam=1.0, v=1.0) staticmethod

Create Mexican hat potential \(V(\phi) = \lambda (|\phi|^2 - v^2)^2\).

Classic symmetry-breaking potential with circular minimum at \(|\phi| = v\).

Parameters:

Name	Type	Description	Default
lam	float	Coupling constant	1.0
v	float	Vacuum expectation value	1.0

Returns:

Type	Description
ScalarPotential	ScalarPotential instance

Source code in jaxlatt/core/potentials.py

@staticmethod
def mexican_hat(lam: float = 1.0, v: float = 1.0) -> "ScalarPotential":
    """
    Create Mexican hat potential $V(\\phi) = \\lambda (|\\phi|^2 - v^2)^2$.

    Classic symmetry-breaking potential with circular minimum at $|\\phi| = v$.

    Args:
        lam: Coupling constant
        v: Vacuum expectation value

    Returns:
        `ScalarPotential` instance
    """
    return ScalarPotential(name="mexican_hat", params=(lam, v))

from_function(potential_fn, name='custom') staticmethod

Create ScalarPotential from an arbitrary function.

Note: Custom functions may not cache as efficiently since they are identified by object id rather than parameters.

Parameters:

Name	Type	Description	Default
potential_fn	PotentialFunction	Function \(V(\phi) \to\) energy density	required
name	str	Identifier for this potential	'custom'

Returns:

Type	Description
ScalarPotential	ScalarPotential instance

Source code in jaxlatt/core/potentials.py

@staticmethod
def from_function(potential_fn: PotentialFunction, name: str = "custom") -> "ScalarPotential":
    """
    Create `ScalarPotential` from an arbitrary function.

    Note: Custom functions may not cache as efficiently since they
    are identified by object id rather than parameters.

    Args:
        potential_fn: Function $V(\\phi) \\to$ energy density
        name: Identifier for this potential

    Returns:
        `ScalarPotential` instance
    """
    # Use id of function as unique identifier
    return ScalarPotential(name=name, params=(id(potential_fn), potential_fn))