neuralqx.lqx.wcl.core.wcl_4d module¶
- class LqxWCL4D(hilbert, graph, gauge_group, *, computational=True, spacetime_dimensions=3, model_name='(3+1)-Euclidean LQG', is_4d=True)¶
Bases:
LqxWCL3D- property H¶
- init_constraint_terms(graph_level)¶
A function which collects all the terms the constraint will act on for a given component in the constraint. Specifically, it finds all possible edge triplets (e₁, e₂, e₃) for every vertex and for every (e₁, e₂), it finds all contributing minimal loops. It also finds all ε(e₁, e₂, e₃) for all edge triplets.
- area(surface, standalone=True, *, squared=False, computational=False, jax=False)¶
Returns the area operator for a surface through which edges pass through. The specified
surfaceshould be a list of edges of the graph which are assumed to pucnture through the desired surface.The area for a given graph is given by
\[\hat{A}(S) |\vec{m}\rangle = \sum_{e \cap S\neq\varnothing} \sqrt{ \big(m_e^{(1)}\big)^2 + \big(m_e^{(2)}\big)^2 + \big(m_e^{(3)}\big)^2 } |\vec{m}\rangle\]i.e. for each edge intersecting (S) take its three U(1) charges, square them, sum, and take the square root. (In the generic normalization one would multiply by 8πℓₚ² here that prefactor is set to 1 by convention, see Notes.)
Orientation of an edge does not affect the result since the operator uses the charge norm. If an edge punctures the surface multiple times, it should be included with several times.
For non-planar graphs, these edges should be supplied in accordance to the edges appearing from the
neuralqx.graph.Graph.edges(that is, not in the non-planar representation).- Notes: here it is assumed the following
unit Planck length
Immirzi parameter of value 1.0
Hence the 8πℓₚ² factor is absorbed into units
- Parameters:
surface (
Union[list,tuple]) – a list of edges passing through the assumed surfacestandalone (
bool) – a flag to determine if the operator will be multiplied with otherLocalOperatortypes or notsquared (
bool) – a flag to determine if the area or area squared is requestedcomputational (
bool) – a flag to determine whether aLocalOperatororComputationalOperatorbased implementation is requestedjax (
Optional[bool]) – a flag to determine whether the returned ComputationalOperator should be ofComputationalOperatororComputationalJaxOperatortype
- Return type:
Union[List,AreaOperator]- Returns:
a FunctionalLocalOperator denoting the area operator for the given surface
- area_difference_squared_operator(edges, standalone=True, *, computational=False, jax=False)¶
Returns an area difference squared operator between two edges such that
\[\langle(\hat{A}_{e_1} - \hat{A}_{e_2})^2\rangle = \langle \hat{A}_{e_1}^2 \rangle + \langle \hat{A}_{e_2}^2 \rangle - 2 \langle \hat{A}_{e_1} \hat{A}_{e_2} \rangle\]where the area operator is constructed according to
EuclideanWCL4D.area_operator()(see its documentation for details).For non-planar graphs, these edges should be supplied in accordance to the edges appearing from the
neuralqx.graph.Graph.edges(that is, not in the non-planar representation).- Notes: here it is assumed when computing the area the following
unit Planck length
Immirzi parameter of value 1.0
Hence the 8πℓₚ² factor in a given area operator is absorbed into units
- Parameters:
edges (
List) – a list of two edges to compute their area difference fromstandalone (
bool) – a flag to determine whether this operator is going to be multiplied with otherLocalOperatortypescomputational (
bool) – a flag to determine whether aLocalOperatororComputationalOperatorbased implementation is requestedjax (
Optional[bool]) – a flag to determine whether the returned ComputationalOperator should be ofComputationalOperatororComputationalJaxOperatortype
- Return type:
Union[List,AreaDifferenceSquaredOperator]- Returns:
a list of operators representing the right hand side of the area difference operator described above
- area_difference_squared_surfaces_operator(surfaces, jax=False)¶
Returns the squared area difference operator between two surfaces (S_1, S_2), each defined as a list of edges, such that
\[\langle(\hat{A}(S_1) - \hat{A}(S_2))^2\rangle = \langle \hat{A}(S_1)^2 \rangle + \langle \hat{A}(S_2)^2 \rangle - 2\,\langle \hat{A}(S_1)\hat{A}(S_2) \rangle.\]Args: :type surfaces:
List:param surfaces: A list of two surfaces, each surface being a list of edges.Example: [[(0,1,0),(0,2,0)], [(0,4,0),(0,3,0)]].
- Parameters:
jax (
bool) – a flag to determine whether the returned ComputationalOperator should be ofComputationalOperatororComputationalJaxOperatortype- Return type:
Note: this operator only has a ComputationalOperator implementation.
- volume(vertex, *, computational=None, jax=None, standalone=False)¶
A method to return the volume operator at a given vertex
- Parameters:
standalone (
bool) – a flag to determine whether the operator is going to be multiplied withLocalOperatortypes or notcomputational (
Optional[bool]) – a flag to determine whether aLocalOperatororComputationalOperatorbased implementation is requestedvertex (
int) – the vertex on which the volume operator acts onjax (
Optional[bool]) – a flag to determine whether the returned ComputationalOperator should be ofComputationalOperatororComputationalJaxOperatortype
- Return type:
- Returns:
the volume operator on that vertex as a LocalSqrtAbsOperator
- thiemann_regularized_constraint(vertex, *, jax=False, fast=True, adjoint=False, apply_lapse=False)¶
A function that creates the Thiemann regularized constraint. This will return the TRC on the specified vertex.
- Parameters:
vertex (
str) – the vertex on which the constraint acts onadjoint (
Optional[bool]) – a flag to determine if the adjoint operator is requestedjax (
Optional[bool]) – a flag to determine whether the returned ComputationalOperator should be ofComputationalOperatororComputationalJaxOperatortypefast (
Optional[bool]) – if True, a faster Numba basedComputationalOperatorimplementation is returnedapply_lapse (
Optional[bool]) – if True, the operator will use the lapse saved in self.lapses
- Return type:
- Returns:
the Thiemann regularized constraint
- thiemann_quadratic_constraint(*, computational=True, jax=True, **kwargs)¶
Return a quadratic constraint object Σᵥ Ĥᵥ Ĥᵥᵀ where Ĥᵥᵀ is the adjoint of the Thiemann regularised constraint at the vertex v.
When
kwargs['adjoint'] = True(default is False), this method returns Σᵥ Ĥᵥᵀ Ĥᵥ instead of Σᵥ Ĥᵥ Ĥᵥᵀ.- Note: for the optional
kwargs, you can specify: kwargs[‘adjoint’] (bool): if set to False, the Σᵥ Ĥᵥ Ĥᵥᵀ version is returned, otherwise Σᵥ Ĥᵥᵀ Ĥᵥ
- kwargs[‘apply_lapse’] (bool): if set to True, lapses will be applied when constructing
the individual constraints.
- kwargs[‘lazy’] (bool): if set to True, the quadratic constraint is implemented using
NetKet’s
Squaredlazy wrapper.
- kwargs[‘fast’] (bool): if True, and
jaxis False, a faster Numba based ComputationalOperatoris returned
- kwargs[‘fast’] (bool): if True, and
- Note: for the optional
- squared_volume(vertex, *, computational=None, jax=None)¶
Returns the squared 3-d spatial volume operator without any Taylor expansion
- taylor_expanded_volume(order, a, vertex, square_root)¶
A function the return the Taylor expansion of \(f(x) = \sqrt{x}\) or \(f(x) = \sqrt{\sqrt{x}}\) where x = volume operator around a point a and up to given order
Essentially, x is \(V^{2}\) where \(V\) is the (2+1)-d volume operator. Therefore, sqrtVol = False then returns an approximation of the volume up to the given order, and sqrtVol = True returns an approximation of \(\sqrt{V}\) up to the given order