def get_pauli_expectation_value(
self,
state_circuit: Circuit,
pauli: QubitPauliString,
valid_check: bool = True,
) -> complex:
"""Calculates the expectation value of the given circuit using the built-in
ProjectQ functionality
:param state_circuit: Circuit that generates the desired state
:math:`\\left|\\psi\\right>`.
:type state_circuit: Circuit
:param pauli: Pauli operator
:type pauli: QubitPauliString
:param valid_check: Explicitly check that the circuit satisfies all required
predicates to run on the backend. Defaults to True
:type valid_check: bool, optional
:return: :math:`\\left<\\psi | P | \\psi \\right>`
:rtype: complex
"""
pauli_tuple = tuple(
(_default_q_index(q), p.name) for q, p in pauli.to_dict().items())
return self._expectation_value(state_circuit,
projectq.ops.QubitOperator(pauli_tuple),
valid_check)
def _gen_PauliTerm(self,
term: QubitPauliString,
coeff: complex = 1.0) -> PauliTerm:
pauli_term = ID() * coeff
for q, p in term.to_dict().items():
pauli_term *= PauliTerm(p.name, _default_q_index(q))
return pauli_term # type: ignore
def _sparse_to_qiskit_pauli(pauli: QubitPauliString,
n_qubits: int) -> qk_Pauli:
x = [False] * n_qubits
z = [False] * n_qubits
for q, p in pauli.to_dict().items():
i = _default_q_index(q)
z[i] = p in (Pauli.Z, Pauli.Y)
x[i] = p in (Pauli.X, Pauli.Y)
return qk_Pauli((z, x))
def add_operator_term(circuit: Circuit, term: QubitPauliString, angle: float):
qubits = []
for q, p in term.to_dict().items():
if p != Pauli.I:
qubits.append(q)
if p == Pauli.X:
circuit.H(q)
elif p == Pauli.Y:
circuit.V(q)
for i in range(len(qubits) - 1):
circuit.CX(i, i + 1)
circuit.Rz(angle, len(qubits) - 1)
for i in reversed(range(len(qubits) - 1)):
circuit.CX(i, i + 1)
for q, p in term.to_dict().items():
if p == Pauli.X:
circuit.H(q)
elif p == Pauli.Y:
circuit.Vdg(q)
def _sparse_to_qiskit_pauli(pauli: QubitPauliString,
n_qubits: int) -> qk_Pauli:
empty = np.zeros(n_qubits)
q_pauli = qk_Pauli(empty, empty)
for q, p in pauli.to_dict().items():
i = _default_q_index(q)
if p in (Pauli.X, Pauli.Y):
q_pauli._x[i] = True
if p in (Pauli.Z, Pauli.Y):
q_pauli._z[i] = True
return q_pauli
def _obs_from_qps(pauli: QubitPauliString) -> Tuple[Observable, QubitSet]:
obs, qbs = [], []
for q, p in pauli.to_dict().items():
obs.append(_observables[p])
qbs.append(q.index[0])
return Observable.TensorProduct(obs), qbs
