def _construct_kth_evolution(self, slice_pauli_list, k, omega):
"""Construct the kth iteration Quantum Phase Estimation circuit"""
a = QuantumRegister(1, name='a')
c = ClassicalRegister(1, name='c')
q = QuantumRegister(self._operator.num_qubits, name='q')
qc = self._state_in.construct_circuit('circuit', q)
# hadamard on a[0]
qc.add_register(a)
qc.u2(0, np.pi, a[0])
# controlled-U
qc_evolutions = Operator.construct_evolution_circuit(
slice_pauli_list, -2 * np.pi, self._num_time_slices, q, a, unitary_power=2 ** (k - 1),
shallow_slicing=self._shallow_circuit_concat
)
if self._shallow_circuit_concat:
qc.data += qc_evolutions.data
else:
qc += qc_evolutions
# global phase due to identity pauli
qc.u1(2 * np.pi * self._ancilla_phase_coef * (2 ** (k - 1)), a[0])
# rz on a[0]
qc.u1(omega, a[0])
# hadamard on a[0]
qc.u2(0, np.pi, a[0])
qc.add_register(c)
qc.barrier(a)
qc.measure(a, c)
return qc
def _construct_qpe_evolution(self):
"""Implement the Quantum Phase Estimation algorithm"""
a = QuantumRegister(self._num_ancillae, name='a')
c = ClassicalRegister(self._num_ancillae, name='c')
q = QuantumRegister(self._operator.num_qubits, name='q')
# initialize state_in
qc = self._state_in.construct_circuit('circuit', q)
# Put all ancillae in uniform superposition
qc.add(a)
qc.u2(0, np.pi, a)
# phase kickbacks via eoh
pauli_list = self._operator.reorder_paulis(
grouping=self._paulis_grouping)
if len(pauli_list) == 1:
slice_pauli_list = pauli_list
else:
if self._expansion_mode == 'trotter':
slice_pauli_list = pauli_list
elif self._expansion_mode == 'suzuki':
slice_pauli_list = Operator._suzuki_expansion_slice_pauli_list(
pauli_list, 1, self._expansion_order)
else:
raise ValueError('Unrecognized expansion mode {}.'.format(
self._expansion_mode))
for i in range(self._num_ancillae):
qc_evolutions = Operator.construct_evolution_circuit(
slice_pauli_list,
-2 * np.pi,
self._num_time_slices,
q,
a,
ctl_idx=i,
shallow_slicing=self._shallow_circuit_concat)
if self._shallow_circuit_concat:
qc.data += qc_evolutions.data
else:
qc += qc_evolutions
# global phase shift for the ancilla due to the identity pauli term
qc.u1(2 * np.pi * self._ancilla_phase_coef * (2**i), a[i])
# inverse qft on ancillae
self._iqft.construct_circuit('circuit', a, qc)
# measuring ancillae
qc.add(c)
qc.barrier(a)
qc.measure(a, c)
self._circuit = qc
def construct_circuit(self, k=None, omega=0):
"""Construct the kth iteration Quantum Phase Estimation circuit.
For details of parameters, please see Fig. 2 in https://arxiv.org/pdf/quant-ph/0610214.pdf.
Args:
k (int): the iteration idx.
omega (float): the feedback angle.
Returns:
QuantumCircuit: the quantum circuit per iteration
"""
k = self._num_iterations if k is None else k
a = QuantumRegister(1, name='a')
c = ClassicalRegister(1, name='c')
q = QuantumRegister(self._operator.num_qubits, name='q')
qc = self._state_in.construct_circuit('circuit', q)
# hadamard on a[0]
qc.add_register(a)
qc.u2(0, np.pi, a[0])
# controlled-U
qc_evolutions = Operator.construct_evolution_circuit(
self._slice_pauli_list,
-2 * np.pi,
self._num_time_slices,
q,
a,
unitary_power=2**(k - 1),
shallow_slicing=self._shallow_circuit_concat)
if self._shallow_circuit_concat:
qc.data += qc_evolutions.data
else:
qc += qc_evolutions
# global phase due to identity pauli
qc.u1(2 * np.pi * self._ancilla_phase_coef * (2**(k - 1)), a[0])
# rz on a[0]
qc.u1(omega, a[0])
# hadamard on a[0]
qc.u2(0, np.pi, a[0])
qc.add_register(c)
qc.barrier(a)
qc.measure(a, c)
return qc
def construct_circuit(self, x, qr=None, inverse=False):
"""
Construct the second order expansion based on given data.
Args:
x (numpy.ndarray): 1-D to-be-transformed data.
qr (QauntumRegister): the QuantumRegister object for the circuit, if None,
generate new registers with name q.
inverse (bool): whether or not inverse the circuit
Returns:
QuantumCircuit: a quantum circuit transform data x.
"""
if not isinstance(x, np.ndarray):
raise TypeError("x must be numpy array.")
if x.ndim != 1:
raise ValueError("x must be 1-D array.")
if x.shape[0] != self._num_qubits:
raise ValueError(
"number of qubits and data dimension must be the same.")
if qr is None:
qc = self._construct_circuit_with_template(x)
else:
qc = QuantumCircuit(qr)
for _ in range(self._depth):
for i in range(self._num_qubits):
qc.u2(0, pi, qr[i])
for pauli in self._pauli_strings:
coeff = self._data_map_func(
self._extract_data_for_rotation(pauli, x))
p = Pauli.from_label(pauli)
qc += Operator.construct_evolution_circuit([[coeff, p]], 1,
1, qr)
if inverse:
qc.data = [gate.inverse() for gate in reversed(qc.data)]
return qc
def construct_circuit(self,
state_register=None,
ancilla_register=None,
aux_register=None,
measure=False):
"""
Construct the Phase Estimation circuit
Args:
state_register (QuantumRegister): the optional register to use for the quantum state
ancilla_register (QuantumRegister): the optional register to use for the ancillary measurement qubits
aux_register (QuantumRegister): an optional auxiliary quantum register
measure (bool): boolean flag to indicate if the built circuit should include ancilla measurement
Returns:
the QuantumCircuit object for the constructed circuit
"""
if self._circuit[measure] is None:
if self._operator is not None:
# check for identify paulis to get its coef for applying global phase shift on ancillae later
num_identities = 0
for p in self._operator.paulis:
if np.all(np.logical_not(p[1].z)) and np.all(
np.logical_not(p[1].x)):
num_identities += 1
if num_identities > 1:
raise RuntimeError(
'Multiple identity pauli terms are present.')
self._ancilla_phase_coef = p[0].real if isinstance(
p[0], complex) else p[0]
if ancilla_register is None:
a = QuantumRegister(self._num_ancillae, name='a')
else:
a = ancilla_register
if state_register is None:
if self._operator is not None:
q = QuantumRegister(self._operator.num_qubits, name='q')
elif self._unitary_circuit_factory is not None:
q = QuantumRegister(
self._unitary_circuit_factory.num_target_qubits,
name='q')
else:
raise RuntimeError('Missing operator specification.')
else:
q = state_register
qc = QuantumCircuit(a, q)
if aux_register is None:
num_aux_qubits, aux = 0, None
if self._state_in_circuit_factory is not None:
num_aux_qubits = self._state_in_circuit_factory.required_ancillas(
)
if self._unitary_circuit_factory is not None:
num_aux_qubits = max(
num_aux_qubits,
self._unitary_circuit_factory.
required_ancillas_controlled())
if num_aux_qubits > 0:
aux = QuantumRegister(num_aux_qubits, name='aux')
qc.add_register(aux)
else:
aux = aux_register
qc.add_register(aux)
# initialize state_in
if self._state_in is not None:
qc.data += self._state_in.construct_circuit('circuit', q).data
elif self._state_in_circuit_factory is not None:
self._state_in_circuit_factory.build(qc, q, aux)
else:
raise RuntimeError('Missing initial state specification.')
# Put all ancillae in uniform superposition
qc.u2(0, np.pi, a)
# phase kickbacks via dynamics
if self._operator is not None:
pauli_list = self._operator.reorder_paulis(
grouping=self._paulis_grouping)
if len(pauli_list) == 1:
slice_pauli_list = pauli_list
else:
if self._expansion_mode == 'trotter':
slice_pauli_list = pauli_list
elif self._expansion_mode == 'suzuki':
slice_pauli_list = Operator._suzuki_expansion_slice_pauli_list(
pauli_list, 1, self._expansion_order)
else:
raise ValueError(
'Unrecognized expansion mode {}.'.format(
self._expansion_mode))
for i in range(self._num_ancillae):
qc_evolutions = Operator.construct_evolution_circuit(
slice_pauli_list,
-2 * np.pi,
self._num_time_slices,
q,
a,
ctl_idx=i,
shallow_slicing=self._shallow_circuit_concat)
if self._shallow_circuit_concat:
qc.data += qc_evolutions.data
else:
qc += qc_evolutions
# global phase shift for the ancilla due to the identity pauli term
qc.u1(2 * np.pi * self._ancilla_phase_coef * (2**i), a[i])
elif self._unitary_circuit_factory is not None:
for i in range(self._num_ancillae):
self._unitary_circuit_factory.build_controlled_power(
qc, q, a[i], 2**i, aux)
# inverse qft on ancillae
self._iqft.construct_circuit('circuit', a, qc)
# measuring ancillae
if measure:
c = ClassicalRegister(self._num_ancillae, name='c')
qc.add_register(c)
qc.barrier(a)
qc.measure(a, c)
self._circuit[measure] = qc
return self._circuit[measure]
