Correlation functions¶

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_1sO_2(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_TM_2sO(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_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.