Expectation values of Pauli strings?

[BoltzmannEntropy]

Hello,
For a tutorial, I am trying to do something very simple, calculating the expectation value of:

Instead of:

hamiltonian = random_pauli_str_generator(N, terms=1)

How can i specify my own Hamiltonian to compare the value with the theoretical one?
Thanks

[LeiZhang-116-4]

One naive example for the expectance calculation could be

from paddle_quantum import Hamiltonian
from paddle_quantum.state import random_state

psi = random_state(2)
pauli_str = [(1.0, 'Z0, Z1'), (2.0, 'X0, Y1')]
H = Hamiltonian(pauli_str)
print("The expectation value of the observable ZZ + 2XY is", psi.expec_val(H))

Above example cannot be used in a QNN, in which case you should try

from paddle_quantum.loss import ExpecVal

loss_fcn = ExpecVal(H)
print("The loss value is", loss_fcn(psi))

[BoltzmannEntropy]

Thank you very much.
For teaching purposes, is this the preferred method?

%reset -f
import numpy as np
from numpy import pi as PI
import paddle 
import paddle_quantum
from paddle import matmul
from paddle_quantum.ansatz import Circuit
from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix
from paddle_quantum.linalg import dagger
from paddle_quantum import Hamiltonian
from paddle_quantum.state import random_state

x0=np.array([1/np.sqrt(2), 1/np.sqrt(2)])
x1=np.array([1,0])
x2=np.array([0,1])

state_lst=(x0,x1,x2)

pauli_str_lst = ([(1.0, 'X0')],[(1.0, 'Y0')],[(1.0, 'Z0')])

for gate in pauli_str_lst:    
#     print (gate)
    H = Hamiltonian(gate)
    for state in state_lst:
        psi=paddle_quantum.State(paddle.to_tensor(state,dtype='complex64'), dtype='complex64')
        print("Gate {}, State {}, Exp-val {}".format(gate, psi, psi.expec_val(H).numpy()))

Gate [(1.0, 'X0')], State [0.70710677+0.j 0.70710677+0.j], Exp-val [0.99999994]
Gate [(1.0, 'X0')], State [1.+0.j 0.+0.j], Exp-val [0.]
Gate [(1.0, 'X0')], State [0.+0.j 1.+0.j], Exp-val [0.]
Gate [(1.0, 'Y0')], State [0.70710677+0.j 0.70710677+0.j], Exp-val [0.]
Gate [(1.0, 'Y0')], State [1.+0.j 0.+0.j], Exp-val [0.]
Gate [(1.0, 'Y0')], State [0.+0.j 1.+0.j], Exp-val [0.]
Gate [(1.0, 'Z0')], State [0.70710677+0.j 0.70710677+0.j], Exp-val [0.]
Gate [(1.0, 'Z0')], State [1.+0.j 0.+0.j], Exp-val [1.]
Gate [(1.0, 'Z0')], State [0.+0.j 1.+0.j], Exp-val [-1.]

Thanks

[LeiZhang-116-4]

Some codes in terms of Hamiltonian and State could be further simplified, as shown below

import numpy as np
import paddle_quantum as pq
from paddle_quantum import Hamiltonian
from paddle_quantum.state import State

pq.set_backend('state_vector')
pq.set_dtype('complex128')

x0 = np.array([1, 1]) / np.sqrt(2)
x1 = np.array([1, 0])
x2 = np.array([0, 1])
state_list = (x0,x1,x2)
pauli_str_list = ([(1.0, 'X0')],[(1.0, 'Y0')],[(1.0, 'Z0')])

for pauli_str in pauli_str_list:
    H = Hamiltonian(pauli_str)
    for vec in state_list:
        psi = State(vec)
        print(f"Observable {H.pauli_words}, State {psi.numpy()}, Exp val {psi.expec_val(H)}")

You can refer to the API documents of Hamiltonian and State for more information.

[BoltzmannEntropy]

Here,

from sympy import Matrix, symbols, sqrt, init_printing
from sympy.physics.quantum import TensorProduct
from IPython.display import display_pretty

init_printing(use_latex=True)


U_I = Matrix([[1,0],
              [0,1]])
U_H = 1/sqrt(2)*Matrix([[1, 1],
                        [1,-1]])

U_Z=Matrix(2,2,[1,0,0,-1])
# U_Z=Matrix(2,2,[1,0,0,-1])

U_ZZ = TensorProduct(U_Z,U_Z)
phi_plus = Matrix(1,4,np.array([1, 0, 0, 1])/np.sqrt(2)).T

# phi_plus*(U_ZZ*phi_plus)
U_ZZ, phi_plus, U_ZZ*phi_plus, U_Z, U_ZZ,  phi_plus.T*(U_ZZ*phi_plus)

I get expectation value of 1 from phi_plus.T*(U_ZZ*phi_plus).

But in paddle:

# matmul(matmul(U, self.rho), dagger(U))
# paddle.kron(proj, X) 
U_Z=paddle.to_tensor([[1,0],[0,-1]], dtype='complex128')
phi_plus = paddle.Tensor(np.array([1, 0, 0, 1])/np.sqrt(2))# | Phi^+ >
phi_plus=paddle.unsqueeze(phi_plus, axis=1)
# U_ZZ = paddle.kron(U_Z,pq.linalg.dagger(U_Z)).numpy()
U_ZZ = paddle.kron(U_Z,U_Z)
exp_val=(phi_plus.T*(U_ZZ*phi_plus)).numpy()
U_ZZ, phi_plus, U_ZZ*phi_plus, exp_val 

I get a matrix instead of a scaler, what am I doing wrong?

In numpy:

U_Z=[[1,0],[0,-1]]
phi_plus = (np.matrix([1, 0, 0, 1])/np.sqrt(2)).T# | Phi^+ >
phi_plus.conj().T*(np.kron(U_Z, U_Z)*phi_plus)
matrix([[1.]])

[BoltzmannEntropy]

?

[LeiZhang-116-4]

The operation * for matrix-like classes (such as sympy.Matrix, numpy.matrix) means matrix multiplication, whereas the operation * for array-like classes (such as numpy.ndarray, paddle.Tensor) means entry-wise multiplication. Please use the symbol @ or the function paddle.matmul instead.

[imppresser]

One naive example for the expectance calculation could be

from paddle_quantum import Hamiltonian
from paddle_quantum.state import random_state

psi = random_state(2)
pauli_str = [(1.0, 'Z0, Z1'), (2.0, 'X0, Y1')]
H = Hamiltonian(pauli_str)
print("The expectation value of the observable ZZ + 2XY is", psi.expec_val(H))

Above example cannot be used in a QNN, in which case you should try

from paddle_quantum.loss import ExpecVal

loss_fcn = ExpecVal(H)
print("The loss value is", loss_fcn(psi))

Hey, thank you, but what if I need to compute <ψ|H^2|ψ>, how to use the psi.expec_val(H)?

[BoltzmannEntropy]

@imppresser see the example here:
https://faculty.washington.edu/seattle/physics541/11solved.pdf

[LeiZhang-116-4]

Hi there. The function State.expec_val() only accepts inputs from class Hamiltonian, to be compatible with the situation when the backend is switched from simulators to real quantum devices.

To calculate $\langle \psi | H^2 |\psi\rangle$, you can use the bra-ket notation and matrix multiplications to complete the job.

from paddle_quantum import Hamiltonian
from paddle_quantum.state import random_state
from paddle_quantum.qinfo import random_pauli_str_generator

num_qubits = 3
psi = random_state(num_qubits)
H = Hamiltonian(random_pauli_str_generator(num_qubits))
H_matrix = paddle.to_tensor(H.construct_h_matrix())

expect_value = psi.bra @ H_matrix @ H_matrix @ psi.ket
print("The pauli string of this Hamiltonian is \n", H.pauli_str)
print("The expectation value is", expect_value.item())

The pauli string of this Hamiltonian is 
 [[0.6976072696164013, 'Z1,Z0'], [0.6145107870116349, 'Z1,X0'], [-0.5089016842519825, 'Y1,Y2,Y0']]
The expectation value is (1.177162766456604-2.9802322387695312e-08j)

[imppresser]

@imppresser see the example here: https://faculty.washington.edu/seattle/physics541/11solved.pdf

Thank you for your detailed lecture note, caculating the H^2 is surely the way. However, in my case need more general way of implementing code of H^2, because the variety of H. Very happy to find the course, it will help a lot!

[imppresser]

Hi there. The function State.expec_val() only accepts inputs from class Hamiltonian, to be compatible with the situation when the backend is switched from simulators to real quantum devices.

To calculate ⟨ψ|H2|ψ⟩, you can use the bra-ket notation and matrix multiplications to complete the job.

from paddle_quantum import Hamiltonian
from paddle_quantum.state import random_state
from paddle_quantum.qinfo import random_pauli_str_generator

num_qubits = 3
psi = random_state(num_qubits)
H = Hamiltonian(random_pauli_str_generator(num_qubits))
H_matrix = paddle.to_tensor(H.construct_h_matrix())

expect_value = psi.bra @ H_matrix @ H_matrix @ psi.ket
print("The pauli string of this Hamiltonian is \n", H.pauli_str)
print("The expectation value is", expect_value.item())

The pauli string of this Hamiltonian is 
 [[0.6976072696164013, 'Z1,Z0'], [0.6145107870116349, 'Z1,X0'], [-0.5089016842519825, 'Y1,Y2,Y0']]
The expectation value is (1.177162766456604-2.9802322387695312e-08j)

Thanks for the detailed feedback. I noticed the "expect_val()" function changed (for compatibility). The solution you give will help me out!

[imppresser]

When N(as qubits) turns big like 18, or above, it shows errors for it cannot allocate this big memory. But using "ExpecVal(H)" would not cause error even as large as 20+. If it is possible to run big tasks while expect_value(H^2)?

[BoltzmannEntropy]

Are you using a GPU? Can I see the a full code snippet?

[imppresser]

Are you using a GPU? Can I see the a full code snippet?

Not using GPU. The problem is to construct h_matrix, it is natural cannot build 2^18 x 2^18 complex64 matrix on PC, it will need 500+GB.

[LeiZhang-116-4]

You have reached another motivation to use the class Hamiltonian. To be specific, the matrices of physical Hamiltonians are usually enriched with zero entries, i.e. the sparse matrix. The linear operations for such matrices can be sped up by tensor contractions (see paddle.einsum used in Paddle Quantum), saving a significant amout of computational resources.

Regarding your question, multiplication for the Hamiltonian class is not yet implemented. But, it has been included for future discussions. For now one naive and possibly expensive approach is to extract the Pauli strings of $H$, calculate the Pauli strings of $H^2$ using the identity of Pauli basis
$$\sigma_j \ \sigma_k = \delta_{jk} \ I + i \epsilon_{jkl} \ \sigma_{l},$$
and then feed the result back into ExpecVal or State.expec_val.