neuralqx.operators.computational.Euclidean4d.numba.vertex_TRC module

An implementation of the vertex Thiemann regularised Euclidean quantum Hamilton constraint of the 4-d model of Euclidean LQG in the WCL as a lightweight ComputationalOperator

class EuclideanVertexTRCOperator(lqx, vertex, *, apply_lapse=True)

Bases: ComputationalOperator

Single-vertex Euclidean Thiemann-regularised constraint \(H_v\) in the 3+1-d U(1)^3 WCL model, copy-resolved on the U(1)^3 factors.

Mathematically:
\[H_v = \frac{1}{T_v}\; \sum_{\text{triplets } j\ni v}\frac{\varepsilon_j}{L_j} \sum_{t\in j}\text{reord}_t \sum_{k=1}^{3} \Big(h_{\alpha_t}^{(k)} - h_{\alpha_t}^{(k)\dagger}\Big)\, \Big(V_v - h_{s_t}^{(k)} V_v h_{s_t}^{(k)-1}\Big)\,,\]

where the superscript \((k)\) means “act only on the k-th U(1) copy”.

Action on a configuration \(\sigma\) (suppressing indices \(j,t,k\) for brevity):

\[ \begin{align}\begin{aligned}\langle h_{\alpha}^{(k)}\sigma | H_v | \sigma \rangle = \frac{1}{T_v}\,\frac{\varepsilon}{L}\,\text{reord}\; \bigl[V_v(\sigma)-V_v(h_{s}^{(k)-1}\sigma)\bigr],\\\qquad \langle h_{\alpha}^{(k)\dagger}\sigma | H_v | \sigma \rangle = - \frac{1}{T_v}\,\frac{\varepsilon}{L}\,\text{reord}\; \bigl[V_v(\sigma)-V_v(h_{s}^{(k)-1}\sigma)\bigr].\end{aligned}\end{align} \]
Computationally:

  • We precompute static index/shifts for each term and for each copy k=0,1,2

  • We emit 6 connections per term (2 signs x 3 copies)

  • Shapes are kept static for JAX jit: lists -> tuples, fixed loop lengths

property is_hermitian

This function must return either True or False based on whether your operator is Hermitian or not. Note that unlike for the case of LocalOperator types, you must specify by-hand whether this operator is Hermitian or not, there is no implementation to deduce that information for you as there is no matrices stored in this operator type.

This property plays a role in determining the computational path to be taken when computing gradients. If you specify that the operator is Hermitian while in reality it is not, the computed gradients will be incorrect.

Returns:

True if this operator is Hermitian, False otherwise

property dtype

Specify a JAX NumPy or NumPy dtype for this operator (that is, what is the dtype of the matrix elements returned by this operator)

class EuclideanVertexTRCOperatorFast(lqx, vertex, *, apply_lapse=True)

Bases: ComputationalOperator

This implementation is numerically identical to the EuclideanVertexTRCOperator implementation, except it is faster.

The implementation is not self-documented, as it aims to mirror the well-documented implementation in the EuclideanVertexTRCOperator class.

property is_hermitian: bool

This function must return either True or False based on whether your operator is Hermitian or not. Note that unlike for the case of LocalOperator types, you must specify by-hand whether this operator is Hermitian or not, there is no implementation to deduce that information for you as there is no matrices stored in this operator type.

This property plays a role in determining the computational path to be taken when computing gradients. If you specify that the operator is Hermitian while in reality it is not, the computed gradients will be incorrect.

Returns:

True if this operator is Hermitian, False otherwise

property dtype: None | str | type[Any] | dtype | _SupportsDType

Specify a JAX NumPy or NumPy dtype for this operator (that is, what is the dtype of the matrix elements returned by this operator)

class EuclideanVertexTRCAdjointOperator(lqx, vertex, *, apply_lapse=True)

Bases: EuclideanVertexTRCOperator

Adjoint of EuclideanVertexTRCOperator.

Core action (per term t, copy k):

(V_v - h_{s_t}^{(k)} V_v h_{s_t}^{(k)dagger}) (h_{α_t}^{(k)dagger} - h_{α_t}^{(k)})

Computationally:
For each branch σ’ ∈ { h_{α}^{(k)}σ, h_{α}^{(k)†}σ }:

ΔV_adj(σ’) = V(σ’) - V(h_{s}^{(k)-1} σ’)

mels:

for σ’ = h_{α}σ -> - coeff_t * ΔV_adj(σ’) for σ’ = h_{α}†σ -> + coeff_t * ΔV_adj(σ’)

class EuclideanVertexTRCAdjointOperatorFast(lqx, vertex, *, apply_lapse=True)

Bases: EuclideanVertexTRCOperatorFast

Fast adjoint version of EuclideanVertexTRCOperatorFast.

ThiemannRegularisedVertexConstraint(lqx, vertex, *, apply_lapse=True, adjoint=False)
ThiemannRegularisedVertexConstraintFast(lqx, vertex, *, apply_lapse=True, adjoint=False)