TransitionListener 2.0.0__py3-none-any.whl

transitionlistener/counterterms/cw.py

@@ -0,0 +1,298 @@
+"""
+Coleman–Weinberg gradient and Hessian utilities.
+
+The functions defined here implement the analytic derivative formulas used in
+BSMPT and ported into TransitionListener.  They operate on the curvature
+tensors evaluated at the vacuum configuration and provide gradient / Hessian
+matrices expressed in the physical field basis (i.e. after rotating into the
+mass eigenstates).
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Tuple
+
+import numpy as np
+
+from transitionlistener.constants import CW_CONSTANTS
+from .tensors import ensure_symmetric
+
+EPS_LOOP = 1.0 / (16.0 * math.pi * math.pi)
+
+
+def _log_term(m2: float, scale_sq: float, counterterm: float) -> float:
+    r"""Return the Coleman-Weinberg logarithmic kernel
+    :math:`\log(m^2/\mu^2) - c + 1/2`, regularised at ``m^2 = 0``."""
+    if m2 == 0.0:
+        return -counterterm + 0.5
+    return math.log(m2 / scale_sq) - counterterm + 0.5
+
+
+def _fbase(m2a: float, m2b: float, scale: float) -> float:
+    """
+    Helper matching ``Class_Potential_Origin::fbase`` in BSMPT.
+    """
+
+    if m2a == 0.0 and m2b == 0.0:
+        return 1.0
+
+    tol = 1e-5
+    log_a = math.log(m2a) - 2.0 * math.log(scale) if m2a != 0.0 else 0.0
+    if abs(m2a - m2b) > tol:
+        log_b = math.log(m2b) - 2.0 * math.log(scale) if m2b != 0.0 else 0.0
+        if m2a == 0.0:
+            return log_b
+        if m2b == 0.0:
+            return log_a
+        return (log_a * m2a - log_b * m2b) / (m2a - m2b)
+    return 1.0 + log_a
+
+
+def coleman_weinberg_derivatives(
+    h2: np.ndarray,
+    h3: np.ndarray,
+    h4: np.ndarray,
+    gauge_curv: np.ndarray,
+    quark_curv: np.ndarray,
+    lepton_curv: np.ndarray,
+    vev: np.ndarray,
+    *,
+    scale: float,
+    scalar_threshold: float = 1e-5,
+    fermion_threshold: float = 1e-10,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Compute the Coleman–Weinberg gradient and Hessian in the physical basis.
+
+    Parameters
+    ----------
+    h2, h3, h4:
+        Higgs curvature tensors (quadratic, cubic, quartic) in the gauge basis.
+    gauge_curv:
+        Gauge curvature tensor :math:`G_{abij}`.
+    quark_curv, lepton_curv:
+        Fermionic Yukawa curvature tensors :math:`Y_{ij\\alpha}`.
+    vev:
+        Vacuum expectation value vector in the Higgs field basis (GeV).
+    scale:
+        Renormalisation scale :math:`\\mu` used in the Coleman–Weinberg logs.
+    scalar_threshold, fermion_threshold:
+        Numerical cut-offs below which eigenvalues are treated as zero.
+
+    Returns
+    -------
+    (gradient, hessian):
+        Coleman–Weinberg first and second derivatives in the physical basis,
+        expressed in the same units as the input tensors.  The overall
+        Coleman–Weinberg loop factor :math:`1/(16 \\pi^2)` is included.
+    """
+
+    scale_sq = scale * scale
+
+    # ------------------------------------------------------------------
+    # Mass matrices and rotations
+    # ------------------------------------------------------------------
+    mass_h = h2.copy()
+    for k in range(vev.shape[0]):
+        mass_h += h3[:, :, k] * vev[k]
+    for k in range(vev.shape[0]):
+        for l in range(vev.shape[0]):
+            mass_h += 0.5 * h4[:, :, k, l] * vev[k] * vev[l]
+
+    mass_g = np.zeros((gauge_curv.shape[0], gauge_curv.shape[1]), dtype=float)
+    for a in range(gauge_curv.shape[0]):
+        for b in range(gauge_curv.shape[1]):
+            total = 0.0
+            for i in range(vev.shape[0]):
+                for j in range(vev.shape[0]):
+                    total += gauge_curv[a, b, i, j] * vev[i] * vev[j]
+            mass_g[a, b] = 0.5 * total
+
+    MIJ_quark = np.tensordot(quark_curv, vev, axes=(2, 0))
+    MIJ_lepton = np.tensordot(lepton_curv, vev, axes=(2, 0))
+
+    mass_quark = MIJ_quark.conj().T @ MIJ_quark
+    mass_lepton = MIJ_lepton.conj().T @ MIJ_lepton
+
+    eigvals_h, eigvecs_h = np.linalg.eigh(mass_h)
+    HiggsRot = np.real_if_close(eigvecs_h.T, tol=1e8)
+    mass_h_sq = eigvals_h.copy()
+    mass_h_sq[np.abs(mass_h_sq) < scalar_threshold] = 0.0
+
+    eigvals_g, eigvecs_g = np.linalg.eigh(mass_g)
+    GaugeRot = np.real_if_close(eigvecs_g.T, tol=1e8)
+    mass_g_sq = eigvals_g.copy()
+    mass_g_sq[np.abs(mass_g_sq) < scalar_threshold] = 0.0
+
+    eigvals_q, eigvecs_q = np.linalg.eigh(mass_quark)
+    QuarkRot = np.real_if_close(eigvecs_q.T, tol=1e8)
+    mass_quark_sq = eigvals_q.real
+    mass_quark_sq[np.abs(mass_quark_sq) < fermion_threshold] = 0.0
+
+    eigvals_l, eigvecs_l = np.linalg.eigh(mass_lepton)
+    LepRot = np.real_if_close(eigvecs_l.T, tol=1e8)
+    mass_lepton_sq = eigvals_l.real
+    mass_lepton_sq[np.abs(mass_lepton_sq) < fermion_threshold] = 0.0
+
+    # ------------------------------------------------------------------
+    # Physical couplings
+    # ------------------------------------------------------------------
+    LambdaGauge3 = np.einsum("abij,j->abi", gauge_curv, vev, optimize=True)
+    LambdaHiggs3 = h3 + np.einsum("abij,j->abi", h4, vev, optimize=True)
+
+    LambdaQuark3 = (
+        np.einsum("ilk,lj->ijk", np.conjugate(quark_curv), MIJ_quark, optimize=True)
+        + np.einsum("il,ljk->ijk", np.conjugate(MIJ_quark), quark_curv, optimize=True)
+    )
+    LambdaQuark4 = (
+        np.einsum("ilk,ljm->ijkm", np.conjugate(quark_curv), quark_curv, optimize=True)
+        + np.einsum("ilm,ljk->ijkm", np.conjugate(quark_curv), quark_curv, optimize=True)
+    )
+
+    LambdaLepton3 = (
+        np.einsum("ilk,lj->ijk", np.conjugate(lepton_curv), MIJ_lepton, optimize=True)
+        + np.einsum("il,ljk->ijk", np.conjugate(MIJ_lepton), lepton_curv, optimize=True)
+    )
+    LambdaLepton4 = (
+        np.einsum("ilk,ljm->ijkm", np.conjugate(lepton_curv), lepton_curv, optimize=True)
+        + np.einsum("ilm,ljk->ijkm", np.conjugate(lepton_curv), lepton_curv, optimize=True)
+    )
+
+    Couplings_Higgs_Triple = np.einsum(
+        "pi,qj,rk,ijk->pqr", HiggsRot, HiggsRot, HiggsRot, LambdaHiggs3, optimize=True
+    )
+    Couplings_Higgs_Quartic = np.einsum(
+        "pi,qj,rk,sl,ijkl->pqrs", HiggsRot, HiggsRot, HiggsRot, HiggsRot, h4, optimize=True
+    )
+    Couplings_Gauge_Higgs_21 = np.einsum(
+        "pa,qb,ri,abi->pqr", GaugeRot, GaugeRot, HiggsRot, LambdaGauge3, optimize=True
+    )
+    Couplings_Gauge_Higgs_22 = np.einsum(
+        "pa,qb,ri,sj,abij->pqrs", GaugeRot, GaugeRot, HiggsRot, HiggsRot, gauge_curv, optimize=True
+    )
+    Couplings_Quark_Higgs_21 = np.einsum(
+        "pa,qb,ri,abi->pqr", QuarkRot, QuarkRot, HiggsRot, LambdaQuark3, optimize=True
+    )
+    Couplings_Quark_Higgs_22 = np.einsum(
+        "pa,qb,ri,sj,abij->pqrs", QuarkRot, QuarkRot, HiggsRot, HiggsRot, LambdaQuark4, optimize=True
+    )
+    Couplings_Lepton_Higgs_21 = np.einsum(
+        "pa,qb,ri,abi->pqr", LepRot, LepRot, HiggsRot, LambdaLepton3, optimize=True
+    )
+    Couplings_Lepton_Higgs_22 = np.einsum(
+        "pa,qb,ri,sj,abij->pqrs", LepRot, LepRot, HiggsRot, HiggsRot, LambdaLepton4, optimize=True
+    )
+
+    # ------------------------------------------------------------------
+    # Gradient
+    # ------------------------------------------------------------------
+    grad_mass_basis = np.zeros(vev.shape[0], dtype=float)
+    cw_gauge = CW_CONSTANTS["gauge"]
+    cw_scalar = CW_CONSTANTS["scalar"]
+    cw_fermion = CW_CONSTANTS["fermion"]
+
+    for i in range(vev.shape[0]):
+        tmp = 0.0
+        for a in range(mass_g_sq.shape[0]):
+            m2 = mass_g_sq[a]
+            if m2 != 0.0:
+                coup = Couplings_Gauge_Higgs_21[a, a, i]
+                tmp += 1.5 * float(coup) * m2 * _log_term(m2, scale_sq, cw_gauge)
+        for a in range(mass_h_sq.shape[0]):
+            m2 = mass_h_sq[a]
+            if m2 != 0.0:
+                coup = Couplings_Higgs_Triple[a, a, i]
+                tmp += 0.5 * float(coup) * m2 * _log_term(m2, scale_sq, cw_scalar)
+        for a in range(mass_quark_sq.shape[0]):
+            m2 = mass_quark_sq[a]
+            if m2 != 0.0:
+                coup = Couplings_Quark_Higgs_21[a, a, i].real
+                tmp -= 3.0 * coup * m2 * _log_term(m2, scale_sq, cw_fermion)
+        for a in range(mass_lepton_sq.shape[0]):
+            m2 = mass_lepton_sq[a]
+            if m2 != 0.0:
+                coup = Couplings_Lepton_Higgs_21[a, a, i].real
+                tmp -= 1.0 * coup * m2 * _log_term(m2, scale_sq, cw_fermion)
+        grad_mass_basis[i] = tmp
+
+    grad_phys = HiggsRot.T @ grad_mass_basis
+    grad_phys = np.real_if_close(grad_phys * EPS_LOOP, tol=1e8)
+
+    # ------------------------------------------------------------------
+    # Hessian
+    # ------------------------------------------------------------------
+    storage = np.zeros((vev.shape[0], vev.shape[0]), dtype=float)
+    for i in range(vev.shape[0]):
+        for j in range(vev.shape[0]):
+            total = 0.0
+            # Gauge sector
+            block = 0.0
+            for a in range(mass_g_sq.shape[0]):
+                for b in range(mass_g_sq.shape[0]):
+                    coup1 = Couplings_Gauge_Higgs_21[a, b, i]
+                    coup2 = Couplings_Gauge_Higgs_21[b, a, j]
+                    br = _fbase(mass_g_sq[a], mass_g_sq[b], scale) - cw_gauge + 0.5
+                    block += float(coup1) * float(coup2) * br
+                if mass_g_sq[a] != 0.0:
+                    coup = Couplings_Gauge_Higgs_22[a, a, i, j]
+                    block += float(coup) * mass_g_sq[a] * _log_term(mass_g_sq[a], scale_sq, cw_gauge)
+            total += 1.5 * block
+
+            # Scalar sector
+            block = 0.0
+            for a in range(mass_h_sq.shape[0]):
+                for b in range(mass_h_sq.shape[0]):
+                    coup1 = Couplings_Higgs_Triple[a, b, i]
+                    coup2 = Couplings_Higgs_Triple[b, a, j]
+                    br = _fbase(mass_h_sq[a], mass_h_sq[b], scale) - cw_scalar + 0.5
+                    block += float(coup1) * float(coup2) * br
+                if mass_h_sq[a] != 0.0:
+                    coup = Couplings_Higgs_Quartic[a, a, i, j]
+                    block += float(coup) * mass_h_sq[a] * _log_term(mass_h_sq[a], scale_sq, cw_scalar)
+            total += 0.5 * block
+
+            # Quark sector
+            block = 0.0
+            for a in range(mass_quark_sq.shape[0]):
+                for b in range(mass_quark_sq.shape[0]):
+                    coup = (
+                        Couplings_Quark_Higgs_21[a, b, i]
+                        * Couplings_Quark_Higgs_21[b, a, j]
+                    ).real
+                    br = _fbase(mass_quark_sq[a], mass_quark_sq[b], scale) - cw_fermion + 0.5
+                    block += coup * br
+                if mass_quark_sq[a] != 0.0:
+                    coup = Couplings_Quark_Higgs_22[a, a, i, j].real
+                    block += coup * mass_quark_sq[a] * _log_term(mass_quark_sq[a], scale_sq, cw_fermion)
+            total -= 3.0 * block
+
+            # Lepton sector
+            block = 0.0
+            for a in range(mass_lepton_sq.shape[0]):
+                for b in range(mass_lepton_sq.shape[0]):
+                    coup = (
+                        Couplings_Lepton_Higgs_21[a, b, i]
+                        * Couplings_Lepton_Higgs_21[b, a, j]
+                    ).real
+                    br = _fbase(mass_lepton_sq[a], mass_lepton_sq[b], scale) - cw_fermion + 0.5
+                    block += coup * br
+                if mass_lepton_sq[a] != 0.0:
+                    coup = Couplings_Lepton_Higgs_22[a, a, i, j].real
+                    block += coup * mass_lepton_sq[a] * _log_term(mass_lepton_sq[a], scale_sq, cw_fermion)
+            total -= block
+
+            storage[i, j] = total
+
+    storage = ensure_symmetric(storage)
+    hess_phys = HiggsRot.T @ storage @ HiggsRot
+    hess_phys = np.real_if_close(hess_phys * EPS_LOOP, tol=1e8)
+
+    return grad_phys, ensure_symmetric(hess_phys)

transitionlistener/counterterms/tensors.py

@@ -0,0 +1,343 @@
+"""
+Low-level helpers for symbolic curvature tensors.
+
+The utilities provided here centralise the JSON I/O that we use to ship SymPy
+expressions from the generator stage to the runtime evaluation.  They also
+offer a thin numerical wrapper around each expression so that models can keep
+their own code short and declarative.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Mapping
+
+import json
+from itertools import permutations
+import numpy as np
+
+from transitionlistener import errors
+
+if TYPE_CHECKING:
+    import sympy as sp
+
+
+def _require_sympy():
+    """Import SymPy on demand and raise a targeted error when it is unavailable."""
+    try:
+        import sympy as sp
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError(
+            "SymPy is required for symbolic counterterm tensor evaluation. "
+            "Install `sympy` to use SymPy-based counterterm models."
+        ) from exc
+    return sp
+
+
+def _is_index_key(key: str) -> bool:
+    """Return whether ``key`` encodes a tensor index tuple such as ``"(0, 1)"``."""
+    key = key.strip()
+    return key.startswith("(") and key.endswith(")")
+
+
+def _parse_index_key(key: str) -> tuple[int, ...]:
+    """Parse a stringified tensor-index tuple back into integers."""
+    stripped = key.strip()[1:-1]
+    if not stripped:
+        return tuple()
+    return tuple(int(part.strip()) for part in stripped.split(","))
+
+
+def _convert_tensor_dict(obj: Any) -> Any:
+    """Recursively turn JSON-loaded tensor data back into SymPy expressions."""
+    sp = _require_sympy()
+    if isinstance(obj, dict):
+        converted = {}
+        for key, value in obj.items():
+            if _is_index_key(key):
+                converted[_parse_index_key(key)] = _convert_tensor_dict(value)
+            else:
+                converted[key] = _convert_tensor_dict(value)
+        return converted
+    if isinstance(obj, list):
+        return [_convert_tensor_dict(item) for item in obj]
+    if isinstance(obj, str):
+        return sp.sympify(obj, evaluate=False)
+    return obj
+
+
+def _initialise_parameter_symbols(
+    metadata: dict[str, Any],
+    *,
+    complex_parameters: tuple[str, ...] = (),
+) -> dict[str, sp.Symbol]:
+    """Construct the SymPy symbols corresponding to the stored metadata labels."""
+    sp = _require_sympy()
+    parameter_aliases = metadata.get("parameter_symbol_names", {})
+    parameter_symbols: dict[str, sp.Symbol] = {}
+    for name in metadata.get("parameters", []):
+        alias = parameter_aliases.get(name, name)
+        alias_expr = sp.sympify(alias)
+        if isinstance(alias_expr, sp.Symbol):
+            base_name = alias_expr.name
+        else:
+            base_name = str(alias)
+            alias_expr = sp.Symbol(base_name)
+        is_complex = base_name in complex_parameters
+        symbol = sp.Symbol(base_name) if is_complex else sp.Symbol(base_name, real=True)
+        for tag in {name, base_name, str(alias)}:
+            parameter_symbols[tag] = symbol
+        parameter_symbols[alias_expr] = symbol
+    metadata["parameter_symbols"] = parameter_symbols
+    return parameter_symbols
+
+
+@lru_cache(maxsize=None)
+def load_tensor_dataset(
+    tensor_file: Path,
+    *,
+    complex_parameters: tuple[str, ...] = (
+        "Vud",
+        "Vus",
+        "Vub",
+        "Vcd",
+        "Vcs",
+        "Vcb",
+        "Vtd",
+        "Vts",
+        "Vtb",
+    ),
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """
+    Load a JSON tensor dataset and return SymPy expressions ready for evaluation.
+
+    Parameters
+    ----------
+    tensor_file:
+        Absolute path to the JSON document produced by the counterterm generator.
+    complex_parameters:
+        Iterable with the subset of parameters that need complex-valued symbols.
+
+    Returns
+    -------
+    (metadata, tensors)
+        Metadata dictionary (augmented with ``parameter_symbols``) and a nested
+        dictionary of SymPy expressions keyed by index tuples.
+    """
+
+    if not tensor_file.exists():
+        raise errors.InitPotentialError(
+            f"Generated tensor file not found: {tensor_file}. "
+            "Run the counterterm generator to create it."
+        )
+
+    with tensor_file.open("r", encoding="utf-8") as fh:
+        raw = json.load(fh)
+
+    metadata = raw.get("metadata", {})
+    _initialise_parameter_symbols(metadata, complex_parameters=complex_parameters)
+    tensors = _convert_tensor_dict(raw.get("tensors", {}))
+    return metadata, tensors
+
+
+def build_substitutions(
+    metadata: Mapping[str, Any],
+    parameter_values: Mapping[str, complex],
+) -> dict[sp.Symbol, complex]:
+    """
+    Construct the substitution dictionary used during tensor evaluation.
+
+    Parameters
+    ----------
+    metadata:
+        Metadata dictionary returned by :func:`load_tensor_dataset`.
+    parameter_values:
+        Mapping from parameter identifiers (as stored in the metadata) to the
+        numerical values provided by the model.
+
+    Returns
+    -------
+    dict
+        Mapping ``sympy.Symbol -> value`` ready to be passed to
+        :func:`evaluate_expression`.
+    """
+
+    sp = _require_sympy()
+    subs: dict[sp.Symbol, complex] = {}
+    param_symbols: dict[str, sp.Symbol] = dict(metadata.get("parameter_symbols", {}))
+    aliases = metadata.get("parameter_symbol_names", {})
+
+    def assign(label: str, value: complex) -> None:
+        symbol = param_symbols.get(label)
+        if symbol is None:
+            symbol = sp.Symbol(label)
+            param_symbols[label] = symbol
+        subs[symbol] = value
+        # Also populate the alias to avoid round trips.
+        alias_label = aliases.get(label)
+        if alias_label is not None:
+            alias_symbol = param_symbols.get(alias_label)
+            if alias_symbol is None:
+                alias_symbol = sp.Symbol(alias_label)
+                param_symbols[alias_label] = alias_symbol
+            subs[alias_symbol] = value
+
+    for key, value in parameter_values.items():
+        assign(str(key), complex(value))
+
+    metadata["parameter_symbols"] = param_symbols  # type: ignore[index]
+    return subs
+
+
+def evaluate_expression(
+    expr: sp.Expr,
+    substitutions: Mapping[sp.Symbol, complex],
+    *,
+    extra_substitutions: Mapping[str | sp.Symbol, complex] | None = None,
+) -> complex | float:
+    """
+    Evaluate a tensor entry to floating-point precision.
+
+    Parameters
+    ----------
+    expr:
+        SymPy expression representing the tensor component.
+    substitutions:
+        Base substitution map generated by :func:`build_substitutions`.
+    extra_substitutions:
+        Optional field-dependent substitutions that should override the base map.
+
+    Returns
+    -------
+    complex
+        Numerical value of the expression.  Purely real results are returned as
+        ``float`` for convenience.
+    """
+
+    sp = _require_sympy()
+    if expr is None:
+        return 0.0
+
+    subs = dict(substitutions)
+    if extra_substitutions:
+        for key, value in extra_substitutions.items():
+            symbol = key if isinstance(key, sp.Symbol) else sp.Symbol(str(key))
+            subs[symbol] = complex(value)
+
+    evaluated = sp.N(expr.subs(subs), 30)
+    free_symbols = getattr(evaluated, "free_symbols", set())
+    if free_symbols:
+        missing = ", ".join(str(sym) for sym in sorted(free_symbols, key=str))
+        raise ValueError(f"Unresolved symbols in tensor evaluation: {missing} (expression: {expr})")
+
+    try:
+        value = complex(evaluated)
+    except TypeError:
+        real_part = float(sp.N(sp.re(evaluated), 30))
+        imag_part = float(sp.N(sp.im(evaluated), 30))
+        value = complex(real_part, imag_part)
+
+    if abs(value.imag) < 1e-12:
+        return float(value.real)
+    if abs(value.real) < 1e-12:
+        return complex(0.0, value.imag)
+    return value
+
+
+def ensure_symmetric(matrix):
+    """
+    Symmetrise a square numerical matrix.
+
+    This helper is used to enforce the hermiticity of Coleman–Weinberg Hessians
+    after evaluating them numerically.
+    """
+
+    return 0.5 * (matrix + matrix.T)
+
+
+def _determine_dim(keys, positions):
+    """Infer an array dimension from the largest index stored in ``keys``."""
+    max_index = 0
+    for key in keys:
+        for pos in positions:
+            max_index = max(max_index, key[pos])
+    return max_index + 1
+
+
+def evaluate_curvature_arrays(
+    tensors: Mapping[str, Any],
+    metadata: Mapping[str, Any],
+    parameter_values: Mapping[str, complex],
+    *,
+    yukawa_key: str,
+) -> dict[str, np.ndarray]:
+    """
+    Evaluate the curvature tensors stored in ``tensors`` using ``parameter_values``.
+    """
+
+    subs = build_substitutions(metadata, parameter_values)
+    n_h = len(metadata.get("field_basis", []))
+    if n_h == 0:
+        n_h = _determine_dim(tensors.get("Curvature_Higgs_L2", {}).keys(), (0, 1))
+
+    h2 = np.zeros((n_h, n_h), dtype=float)
+    for (i, j), expr in tensors.get("Curvature_Higgs_L2", {}).items():
+        value = float(evaluate_expression(expr, subs))
+        h2[i, j] = value
+        h2[j, i] = value
+
+    h3 = np.zeros((n_h, n_h, n_h), dtype=float)
+    for key, expr in tensors.get("Curvature_Higgs_L3", {}).items():
+        value = float(evaluate_expression(expr, subs))
+        for perm in set(permutations(key)):
+            h3[perm] = value
+
+    h4 = np.zeros((n_h, n_h, n_h, n_h), dtype=float)
+    for key, expr in tensors.get("Curvature_Higgs_L4", {}).items():
+        value = float(evaluate_expression(expr, subs))
+        for perm in set(permutations(key)):
+            h4[perm] = value
+
+    gauge_data = tensors.get("Curvature_Gauge_G2H2", {})
+    if gauge_data:
+        n_g = _determine_dim(gauge_data.keys(), (0, 1))
+    else:
+        n_g = 0
+    gauge = np.zeros((n_g, n_g, n_h, n_h), dtype=float)
+    for (a, b, i, j), expr in gauge_data.items():
+        value = float(evaluate_expression(expr, subs))
+        gauge[a, b, i, j] = value
+        gauge[a, b, j, i] = value
+        gauge[b, a, j, i] = value
+        gauge[b, a, i, j] = value
+
+    quark_data = tensors.get("Curvature_Quark_F2H1", {}).get(yukawa_key, {})
+    lepton_data = tensors.get("Curvature_Lepton_F2H1", {}).get(yukawa_key, {})
+
+    n_q = _determine_dim(quark_data.keys(), (0, 1)) if quark_data else 0
+    n_l = _determine_dim(lepton_data.keys(), (0, 1)) if lepton_data else 0
+
+    quark = np.zeros((n_q, n_q, n_h), dtype=complex)
+    for (i, j, k), expr in quark_data.items():
+        quark[i, j, k] = evaluate_expression(expr, subs)
+
+    lepton = np.zeros((n_l, n_l, n_h), dtype=complex)
+    for (i, j, k), expr in lepton_data.items():
+        lepton[i, j, k] = evaluate_expression(expr, subs)
+
+    return {
+        "H2": h2,
+        "H3": h3,
+        "H4": h4,
+        "Gauge": gauge,
+        "Quark": quark,
+        "Lepton": lepton,
+    }