Correlation functions¶

ctm.generic.corrf.apply_TM_0sO(coord, direction, state, env, edge, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction in which the transfer operator is applied
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
edge (torch.tensor) – tensor of dimensions \(\chi^2\)
verbosity (int) – logging verbosity

Returns:

edge with a single instance of the transfer matrix applied The resulting tensor has an identical index structure as the original edge

Return type:

torch.tensor

Applies a single instance of the “0-width channel” transfer matrix of site r=(x,y) to the edge tensor by contracting the following network, or its corresponding rotation depending on the direction:

direction:  right=(1,0)                down=(0,1)

         -----T--                    edge
        |     |                     |    |
         -----T--                   T----T
                                    |    |

ctm.generic.corrf.apply_TM_1sO(coord, direction, state, env, edge, op=None, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction in which the transfer operator is applied
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
edge (torch.tensor) – tensor of dimensions \(\chi \times D^2 \times \chi (\times d_{MPO})\), potentially with 4th index beloning to some MPO
op (torch.tensor) – operator to be inserted into transfer matrix
verbosity (int) – logging verbosity

Returns:

edge with a single instance of the transfer matrix applied The resulting tensor has an identical index structure as the original edge

Return type:

torch.tensor

Applies a single instance of the transfer matrix of site r=(x,y) to the edge tensor by contracting the following network, or its corresponding rotation depending on the direction:

direction:  right=(1,0)                down=(0,1)

         -----T----------------      --------edge--------
        |     |                     |         |          |\
       edge--(a(r)^+ op a(r))--     T--(a(r)^+ op a(r))--T \
        |     |                     |         |          | (MPO)
         -----T----------------
        (\-----------------MPO)

where the physical indices s and s’ of the on-site tensor \(a\) and it’s hermitian conjugate \(a^\dagger\) are contracted with identity \(\delta_{s,s'}\) or op (if supplied). Potentially, the edge can carry an extra MPO index.

ctm.generic.corrf.apply_TM_2sO_1sChannel(coord, direction, state, env, edge, op=None, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction in which the transfer operator is applied
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
edge (torch.tensor) – tensor of dimensions \(\chi \times D^2 \times \chi\)
op (torch.tensor) – two-site operator to be inserted into the two consecutive transfer matrices
verbosity (int) – logging verbosity

Returns:

edge with two transfer matrices (and operator op, if any) applied. The resulting tensor has an identical index structure as the original edge

Return type:

torch.tensor

Applies two transfer matrices to the edge tensor, including the two-site operator op. The applied transfer matrices depend on the selected site r=(x,y) and the direction of the growth. The following network is contracted:

  -----T-------------------T--------------------------
 |     |                   |
edge--(a(r)^+ op_l a(r))==(a(r+dir)^+ op_r a(r+dir))--
 |     |                   |
  -----T-------------------T--------------------------

where the physical indices s and s’ of the on-site tensor \(a\) and it’s hermitian conjugate \(a^\dagger\) are contracted with identity \(\delta_{s,s'}\) or op_l and op_r if op is supplied. The op_l and op_r are given by the SVD decomposition of the two-site operator op:

 0  1        0           1          0            1->0
 |  |  SVD   |           |          |            |
| op |  =  |op_l|--(S--|op^~_r|) = |op_l|--2 2--|op_r|
 |  |        |           |          |            |
 2  3        2           3          2->1         3->1

ctm.generic.corrf.apply_TM_2sO_2sChannel(coord, direction, state, env, edge, op=None, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction in which the transfer operator is applied
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
edge (torch.tensor) – tensor of dimensions \(\chi \times (D^2)^2 \times \chi\)
op (torch.tensor) – two-site operator to be inserted within the two-site transfer matrix
verbosity (int) – logging verbosity

Returns:

edge with a single instance of the transfer matrix applied The resulting tensor has an identical index structure as the original edge

Return type:

torch.tensor

Applies a single instance of the two-site “transfer matrix” with site r=(x,y) to the edge tensor by contracting the following network, or its corresponding rotation depending on the direction:

direction:  right=(1,0)                       down=(0,1)

         -----T--------------------     --------edge-------------
        |     |                        |    |          |         |
       edge--(a(r)^+ o1 a(r))------    T--(a(r)^+)---(a(r+x)^+)--T
        |     |        \               |\   o1---------o2        |
        |----(a(r+y)^+) o2 a(r+y)--    | --a(r)-------a(r+x)-----T
        |     |                        |    |          |         |
         -----T--------------------

The two-site operator is first decomposed into a simple MPO o1–o2 (TODO case where op comes with extra MPO index):

 s1'  s2'    s1'      s2'
|  op   | = |o1|-----|o2|
 s1   s2     s1       s2

where the physical indices s and s’ of the on-site tensor \(a\) and it’s hermitian conjugate \(a^\dagger\) are contracted with identity \(\delta_{s,s'}\) or o1, o2. The transfer matrix is always grown from left to right or from top to bottom.

ctm.generic.corrf.apply_edge(coord, direction, state, env, vec, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction of the edge
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
vec (torch.tensor) – tensor of dimensions \(\chi \times (D^2)^l \times \chi\) representing an edge of length l
verbosity (int) – logging verbosity

Returns:

scalar resulting from the contraction of vec with an edge built from the environment

Return type:

torch.tensor

Contracts vec tensor with the edge of length l defined by coord site and a chosen direction. Afterwards, their dot product is computed:

                    get_edge(coord,direction,...)
           ------0 0------C
          |               |
scalar = vec-----1 1------T
          |               |
         ...--         --...
          |               |
           --(V+1) (V+1)--C

ctm.generic.corrf.corrf_1sO1sO(coord, direction, state, env, op1, get_op2, dist, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – orientation of correlation function
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
op1 (torch.tensor) – first one-site operator \(O_1\)
get_op2 (function(int)->torch.tensor) – function returning (position-dependent) second one-site operator \(\text{get_op2}(r)=O_2\)
dist (int) – maximal distance of correlation function
verbosity (int) – logging verbosity

Returns:

vector corrf of length dist holding the values of correlation function \(\langle O_1(0) O_2(r) \rangle\) for \(r \in [1,dist]\)

Return type:

torch.tensor

Computes the two-point correlation function \(\langle O_1(0) O_2(r) \rangle\) by contracting the following network:

C-----T------- ... -----T------- ... ------T----------C
|     |                 |                  |          |
|    a(0)^+            a(i)^+             a(r)^+      |
T--( op_1  )-- ... --(  |    )-- ... --( gen_op2(r))--T
|    a(0))             a(i)               a(r)        |
|     |                 |                  |          |
C-----T------- ... -----T------- ... ------T----------C

for increasingly large distance r up to dist. The op1 is applied at site 0=(x,y), the transfer matrices are applied in the direction up to site \(r=(x,y) + \text{dist} \times \text{direction}\).

ctm.generic.corrf.corrf_2sOH2sOH_E1(coord, direction, state, env, op1, get_op2, dist, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – orientation of correlation function
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
op1 (torch.tensor) – first two-site operator \(O_1\)
get_op2 (function(int)->torch.tensor) – function returning (position-dependent) second two-site operator \(\text{get_op2}(r)=O_2\)
dist (int) – maximal distance of correlation function
verbosity (int) – logging verbosity

Returns:

vector corrf of length dist holding the values of correlation function \(\langle O_1(0) O_2(r) \rangle\) for \(r \in [1,dist]\)

Return type:

torch.tensor

Computes the correlation function \(\langle O_1(0) O_2(r) \rangle\) of two horizontaly-oriented two-site operators by contracting the following network:

C-----T-------T---------- ... ---T---- ... -----T-------T-------------C
|     |       |                  |              |       |             |
|   /-a(0)^+--a(1)^+-\           a(i)^+      /--a(r)^+--a(r+1)^+--\   |
T--<    ( op 1 )      >-- ... --<|>-- ... --<  (gen_op2(r))        >--T
|   \-a(0)----a(1)---/           a(i))       \--a(r)----a(r+1)----/   |
|     |       |                  |              |       |             |
C-----T-------T---------- ... ---T---- ... -----T-------T-------------C

for increasingly large distance r up to dist+1. The op1 is applied at site 0=(x,y) & 1, the transfer matrices are applied in the direction up to site \(r=(x,y) + \text{dist} \times \text{direction}\)

ctm.generic.corrf.corrf_2sOV2sOV_E2(coord, direction, state, env, op1, get_op2, dist, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – orientation of correlation function
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
op1 (torch.tensor) – first two-site operator \(O_1\)
get_op2 (function(int)->torch.tensor) – function returning (position-dependent) second two-site operator \(\text{get_op2}(r)=O_2\)
dist (int) – maximal distance of correlation function
verbosity (int) – logging verbosity

Returns:

vector corrf of length dist holding the values of correlation function \(\langle O_1(0) O_2(r) \rangle\) for \(r \in [1,dist]\)

Return type:

torch.tensor

Computes the four-point correlation function \(\langle O_1(0) O_2(r) \rangle\), where both O_1 and O_2 are two-site operator by contracting the following network:

C-----T--------------- ... ----T------------- ... -----T-------------C
|     |                        |                       |             |
T--(a(0)^+-----a(0))-- ... --a(i)^+(ai)------ ... --(a(r)^+a(r)------T
|          op1                 |                   ( gen_op2(r))     |
T--(a(y)^+-----a(y))-- ... --a(i+y)^+a(i+y)-- ... --(a(r+y)^+a(r+y)--T
|     |                        |                       |             |
C-----T--------------- ... ----T------------- ... -----T-------------C

for increasingly large distance r up to dist. The op1 is applied within the transfer matrix defined by site 0=(x,y). The transfer matrices are applied in the direction up to site \(r=(x,y) + \text{dist} \times \text{direction}\).

ctm.generic.corrf.get_edge(coord, direction, state, env, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction of the edge
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
verbosity (int) – logging verbosity

Returns:

tensor with indices \(\chi \times D^2 \times \chi\)

Return type:

torch.tensor

Build an edge of site coord by contracting one of the following networks depending on the chosen direction:

    up=(0,-1)   left=(-1,0)  down=(0,1)   right=(1,0)

                 C--0         0  1  2       0--C
                 |            |  |  |          |
E =  C--T--C     T--1         C--T--C       1--T
     |  |  |     |                             |
     0  1  2     C--2                       2--C

The indices of the resulting tensor are always ordered from left-to-right and from up-to-down.

ctm.generic.corrf.get_edge_2(coord, direction, state, env, verbosity=0)[source]¶

Parameters:

coord (tuple(int,int)) – tuple (x,y) specifying vertex on a square lattice
direction (tuple(int,int)) – direction of the edge
state (IPEPS) – underlying wavefunction
env (ENV) – environment corresponding to state
verbosity (int) – logging verbosity

Returns:

tensor with indices \(\chi \times D^2 \times \chi\)

Return type:

torch.tensor

Build an edge of two sites, starting at position coord, by contracting one of the following networks depending on the chosen direction:

    up=(0,-1)   left=(-1,0)  down=(0,1)   right=(1,0)

                C--0         0  1  2  3    0--C
                |            |  |  |  |       |
E = C--T--T--C  T--1         C--T--T--C    1--T
    |  |  |  |  |                             |
    0  1  2  3  T--2                       2--T
                |                             |
                C--3                       3--C

The edge itself is grown from top to bottom or from left to right. The indices of the resulting tensor are always ordered from left-to-right and from up-to-down.