Abelian-symmetric generic Kagome iPESS¶

Specialized sub-class of ipeps.ipeps_kagome_abelian.IPEPS_KAGOME_ABELIAN. A single on-site tensor representing DoFs on down triangle is built from five different tensors: two rank-3 trivalent tensors with only auxiliary indices and three rank-3 bond tensors, each associated to one of the physical DoFs on the vertices of the down triangle.

class ipeps.ipess_kagome_abelian.IPESS_KAGOME_GENERIC_ABELIAN(settings, ipess_tensors, build_sites=True, peps_args=<config.PEPSARGS object>, global_args=<config.GLOBALARGS object>)[source]¶

Bases: IPEPS_KAGOME_ABELIAN

Parameters:

settings (NamedTuple or SimpleNamespace (TODO link to definition)) – YAST configuration
ipess_tensors (dict(str, yast.Tensor)) – dictionary of five tensors, which make up Kagome iPESS ansatz
peps_args (PEPSARGS) – ipeps configuration
global_args (GLOBALARGS) – global configuration

iPESS ansatz for Kagome lattice composes five tensors, specified by dictionary:

ipess_tensors = {'T_u': yast.Tensor, 'T_d': ..., 'B_a': ..., 'B_b': ..., 'B_c': ...}

into a single rank-5 on-site tensor of parent IPEPS. These iPESS tensors can be accessed through member ipess_tensors.

The 'B_*' are rank-3 tensors, with index structure [p,i,j] where the first index p is for physical degree of freedom, while indices i and j are auxiliary. These bond tensors reside on corners shared between different triangles of Kagome lattice. Bond tensors are connected by rank-3 trivalent tensors 'T_u', 'T_d' on up and down triangles respectively. Trivalent tensors have only auxiliary indices.

The on-site tensors of corresponding iPEPS is obtained by the following contraction:

    2(d)            2(c)                    (-)a
     \             /          rot. pi          |
0(w)==B_a         B_b==0(v)   clockwise  (-)b--\
       \         /             =>               \
       1(l)     1(k)                            s0--s2--d(+)
        2(l)   1(k)                              | /
          \   /                                  |/   <- DOWN_T
           T_d                                  s1
            |                                    |
            0(j)                                 c(+)
            1(j)
            |
            B_c==0(u)
            |
            2(i)
            0(i)
            |
           T_u
          /   \
        1(a)   2(b)

where the signature convetions of trivalent and bond tensors are as follows:

(-)\ /(-)     (-)|             |(-)
    T_d   ,     T_u     , (+)--B--(+)
    |(-)    (-)/   \(-)

This choice guarantees that the signature of on-site tensor of equivalent single-site IPEPS_KAGOME_ABELIAN is compatible.

By construction, the degrees of freedom on down triangle are all combined into a single on-site tensor of iPEPS. Instead, DoFs on the upper triangle have to be accessed by construction of 2x2 patch (which is then embedded into environment):

C    T             T          C
     a             a
     |             |
T b--\          b--\
      \        /    \
      s0--s2--d     s0--s2--d T
       | /           | /
       |/            |/
      s1            s1
       |             |
       c             c
      /             /
     a             a
     |             |
T b--\          b--\
      \        /    \
      s0--s2--d     s0--s2--d T
       | /           | /
       |/            |/
      s1            s1
       |             |
       c             c
C      T             T        C

add_noise(noise=0, peps_args=<config.PEPSARGS object>)[source]¶

Parameters:: noise (float) – magnitude of the noise
Returns:: a copy of state with noisy ipess_tensors. For default value of noise being zero self is returned.
Return type:: IPESS_KAGOME_GENERIC_ABELIAN

Create a new state by adding random uniform noise with magnitude noise to all copies of ipess_tensors. The noise is added to all allowed blocks making up the individual tensors. If noise is 0, returns self.

build_onsite_tensors()[source]¶

Returns:: elementary unit cell of underlying IPEPS
Return type:: dict[tuple(int,int): yast.Tensor]

Build on-site tensor of corresponding IPEPS_KAGOME_ABELIAN be performing following contraction of ipess_tensors:

    2(-7)          2(-6)                    (-)(-4)
     \             /          rot. pi             |
0(-3)==B_a        B_b==0(-2)  clockwise  (-)(-5)--\
       \         /             =>                  \
       1(3)     1(2)                                s0(-1)--s2(-3)--(-7)(+)
        2(3)   1(2)                                 | /
          \   /                                     |/   <- DOWN_T
           T_d                                      s1(-2)
            |                                       |
            0(1)                                   (-6)(+)
            1(1)
            |
            B_c==0(-1)
            |
            2(0)
            0(0)
            |
           T_u
          /   \
        1(-4)  2(-5)

generate_weights()[source]¶

Returns:: dictionary of weights on non-equivalent bonds of the iPESS ansatz
Return type:: dict( str: yast.Tensor )

Generate a set of identity tensors, weights W, for each non-equivalent link in the iPESS ansatz:

    2(d)            2(c)                    (-)a
     \             /          rot. pi          |
0(w)==B_a         B_b==0(v)   clockwise  (-)b--\
       \         /             =>               \
       1(l)     1(k)                            s0--s2--d(+)
     W_down_a  W_down_b                          |  /
        2(l)   1(k)                              | /
          \   /                                  |/   <- DOWN_T
           T_d                                  s1
            |                                    |
            0(j)                                 c(+)
          W_down_c
            1(j)
            |
            B_c==0(u)
            |
            2(i)
           W_up_c
            0(i)
            |
           T_u
          /   \
        1(a)   2(b)
      W_up_b   W_up_a

get_checkpoint()[source]¶

Returns:: serializable representation of IPESS_KAGOME_GENERIC_ABELIAN state
Return type:: dict

Return dict containing serialized ipess_tensors (block-sparse) tensors. The individual blocks are serialized into Numpy ndarrays. This function is called by optimizer to create checkpoints during the optimization process.

get_parameters()[source]¶

Returns:: variational parameters of IPESS_KAGOME_GENERIC_ABELIAN
Return type:: iterable

This function is called by optimizer to access variational parameters of the state. In this case member ipess_tensors.

load_checkpoint(checkpoint_file)[source]¶

Parameters:: checkpoint_file (str or file object) – path to checkpoint file

Initializes IPESS_KAGOME_GENERIC_ABELIAN from checkpoint file.

to_dense(peps_args=<config.PEPSARGS object>, global_args=<config.GLOBALARGS object>)[source]¶

Returns:: returns equivalent dense state with all on-site tensors in their dense representation on PyTorch backend.
Return type:: IPESS_KAGOME_GENERIC_ABELIAN

Create an IPESS_KAGOME_GENERIC state with all ipess_tensors as dense possesing no explicit block structure (symmetry). This operations preserves gradients on the returned dense state.

write_to_file(outputfile, tol=None, normalize=False)[source]¶: Writes state to file. See write_ipeps().

ipeps.ipess_kagome_abelian.read_ipess_kagome_generic(jsonfile, settings, peps_args=<config.PEPSARGS object>, global_args=<config.GLOBALARGS object>)[source]¶

Parameters:

jsonfile (str or Path object) – input file describing IPESS_KAGOME_GENERIC_ABELIAN in json format
settings (NamedTuple or SimpleNamespace (TODO link to definition)) – YAST configuration
peps_args (PEPSARGS) – ipeps configuration
global_args (GLOBALARGS) – global configuration

Returns:

wavefunction

Return type:

IPESS_KAGOME_GENERIC_ABELIAN

Read IPESS_KAGOME_GENERIC_ABELIAN from file.

ipeps.ipess_kagome_abelian.write_ipess_kagome_generic(state, outputfile, tol=None, normalize=False, peps_args=<config.PEPSARGS object>, global_args=<config.GLOBALARGS object>)[source]¶

Parameters:

state (IPESS_KAGOME_GENERIC_ABELIAN) – wavefunction to write out in JSON format
outputfile – target file
tol (float) – minimum magnitude of tensor elements which are written out
normalize (bool) – if True, ipess tensors are normalized before writing

Write IPESS_KAGOME_GENERIC_ABELIAN to file.