neuralqx.operators.computational.qr.numba package

class EuclideanConstraint(H, *, lapse=1.0, power=0.25, immirzi=1.0)

Bases: ComputationalOperator

Quantum-Reduced LQG Euclidean constraint on a Single-Vertex-Graph with 3 edges. The convention here is (x = 0, y = 1, z = 2).

Definition reproduced in Discrete form:

C_E = -lapse * (t1 + t2 + t3)

with, for (a,b,z) being a permutation of (0,1,2),

t(a,b|z) = F(a,b|z) * s(a) * s(b) * F(a,b|z),

where

  • s(e) = (1/2) * (C_e - A_e), non-cyclic single-step raise/lower

  • F(a,b|z) = E(a)^(1/4) * E(b)^(1/4) * [E(z)]^(-1/4) (E_inv on z)

  • C_e tries to add +step, A_e tries to add -step, invalid moves give zero contrib

Action:
For each input configuration σ, this operator emits up to 12 connected configurations:
4 from each pair (a,b) ∈ {(0,1), (0,2), (1,2)} with weights:

(1/4) * sign * lapse * F(σ’) * F(σ),

where sign ∈ {+1,-1,-1,+1} corresponds to (+,+), (+,-), (-,+), (-,-).

Notes

  • Hermitian (weights are real scalars, left/right diagonal prefactors applied).

  • dtype: float64

  • Non-cyclic: attempts to step outside [state_min, state_max] are discarded (weight 0).

class LorentzianConstraint(H, *, immirzi=1.0)

Bases: ComputationalOperator

Quantum-Reduced LQG Lorentzian constraint on a single-vertex, 3-edge graph.

With edge labels (x, y, z) = (0, 1, 2):

H_L = -16 * (D_x^2 + D_y^2 + D_z^2)

where for each direction d in {x,y,z}:

D_d = F_d^(1/4) * (1/2) * (1 - c(d)) * F_d^(1/4),

F_x = E(x)^(3/2) * E(y)^(-1/2) * E(z)^(-1/2), F_y = E(y)^(3/2) * E(x)^(-1/2) * E(z)^(-1/2), F_z = E(z)^(3/2) * E(x)^(-1/2) * E(y)^(-1/2).

Implementation notes:

  • c(d) = (1/2) * (C_d + A_d) with non-cyclic single-step shifts.

  • Per direction, D_d has three one-step channels:

    diag (delta=0, coeff=+1/2), raise (delta=+1, coeff=-1/4), lower (delta=-1, coeff=-1/4).

  • D_d^2 is evaluated explicitly by summing all 3x3 path combinations.

  • Total padded connection count is fixed to 3 directions * 9 paths = 27.

class QRFlux(H, *, site, power=1.0, inverse=False)

Bases: ComputationalOperator

QRLG flux operator on a single site site:

  • Diagonal in the computational basis

  • Eigenvalue f(s_site) with

    if inverse == False: f(e) = e^power if inverse == True: f(e) = (1/e)^power, with 0 -> 0.

Discrete representation:

  • Emits exactly one connected configuration (itself)

  • Matrix element is the diagonal eigenvalue

class QRCreation(H, *, site, n=1)

Bases: ComputationalOperator

Non-cyclic QRLG creation operator on a single site site with step n:

(C_n ψ)(…, s_site, …) = ψ(…, s_site - n*step, …)

in the ordered basis of local states, i.e. it raises the local label by n steps. If the raised value would leave the allowed range [state_min, state_max], the contribution is zero.

  • At most 1 connected configuration per input configuration

  • Matrix element is 1.0 when the move is valid, else 0

class QRAnnihilation(H, *, site, n=1)

Bases: ComputationalOperator

Non-cyclic QRLG annihilation operator on a single site site with step n:

(A_n ψ)(…, s_site, …) = ψ(…, s_site + n*step, …)

in the ordered basis of local states, i.e. it lowers the local label by n steps. If the lowered value would leave the allowed range [state_min, state_max], the contribution is zero.

  • At most 1 connected configuration per input

  • Matrix element is 1.0 when valid, else 0

Submodules