def test_exact_reciprocal(self, num_qubits, scaling, neg_vals):
"""Test the ExactReciprocal class."""
reciprocal = ExactReciprocal(num_qubits + neg_vals, scaling, neg_vals)
qc = QuantumCircuit(num_qubits + 1 + neg_vals)
qc.h(list(range(num_qubits)))
# If negative eigenvalues, set the sign qubit to 1
if neg_vals:
qc.x(num_qubits)
qc.append(reciprocal, list(range(num_qubits + 1 + neg_vals)))
# Create the operator 0
state_vec = quantum_info.Statevector.from_instruction(
qc).data[-(2**num_qubits):]
# Remove the factor from the hadamards
state_vec *= np.sqrt(2)**num_qubits
# Analytic value
exact = []
for i in range(0, 2**num_qubits):
if i == 0:
exact.append(0)
else:
if neg_vals:
exact.append(-scaling / (1 - i / (2**num_qubits)))
else:
exact.append(scaling * (2**num_qubits) / i)
np.testing.assert_array_almost_equal(state_vec, exact, decimal=2)
def construct_circuit(
self, matrix: Union[np.ndarray, QuantumCircuit],
vector: Union[np.ndarray, QuantumCircuit]) -> QuantumCircuit:
"""Construct the HHL circuit.
Args:
matrix: The matrix specifying the system, i.e. A in Ax=b.
vector: The vector specifying the right hand side of the equation in Ax=b.
Returns:
The HHL circuit.
Raises:
ValueError: If the input is not in the correct format.
ValueError: If the type of the input matrix is not supported.
"""
# State preparation circuit - default is qiskit
if isinstance(vector, QuantumCircuit):
nb = vector.num_qubits
vector_circuit = vector
elif isinstance(vector, np.ndarray):
nb = int(np.log2(len(vector)))
vector_circuit = QuantumCircuit(nb)
vector_circuit.isometry(vector / np.linalg.norm(vector),
list(range(nb)), None)
# If state preparation is probabilistic the number of qubit flags should increase
nf = 1
# Hamiltonian simulation circuit - default is Trotterization
if isinstance(matrix, QuantumCircuit):
matrix_circuit = matrix
elif isinstance(matrix, (list, np.ndarray)):
if isinstance(matrix, list):
matrix = np.array(matrix)
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Input matrix must be square!")
if np.log2(matrix.shape[0]) % 1 != 0:
raise ValueError("Input matrix dimension must be 2^n!")
if not np.allclose(matrix, matrix.conj().T):
raise ValueError("Input matrix must be hermitian!")
if matrix.shape[0] != 2**vector_circuit.num_qubits:
raise ValueError("Input vector dimension does not match input "
"matrix dimension! Vector dimension: " +
str(vector_circuit.num_qubits) +
". Matrix dimension: " + str(matrix.shape[0]))
matrix_circuit = NumPyMatrix(matrix, evolution_time=2 * np.pi)
else:
raise ValueError(f'Invalid type for matrix: {type(matrix)}.')
# Set the tolerance for the matrix approximation
if hasattr(matrix_circuit, "tolerance"):
matrix_circuit.tolerance = self._epsilon_a
# check if the matrix can calculate the condition number and store the upper bound
if hasattr(matrix_circuit, "condition_bounds") and matrix_circuit.condition_bounds() is not\
None:
kappa = matrix_circuit.condition_bounds()[1]
else:
kappa = 1
# Update the number of qubits required to represent the eigenvalues
nl = max(nb + 1, int(np.log2(kappa)) + 1)
# check if the matrix can calculate bounds for the eigenvalues
if hasattr(matrix_circuit,
"eigs_bounds") and matrix_circuit.eigs_bounds() is not None:
lambda_min, lambda_max = matrix_circuit.eigs_bounds()
# Constant so that the minimum eigenvalue is represented exactly, since it contributes
# the most to the solution of the system
delta = self._get_delta(nl, lambda_min, lambda_max)
# Update evolution time
matrix_circuit.evolution_time = 2 * np.pi * delta / lambda_min
# Update the scaling of the solution
self.scaling = lambda_min
else:
delta = 1 / (2**nl)
print("The solution will be calculated up to a scaling factor.")
if self._exact_reciprocal:
reciprocal_circuit = ExactReciprocal(nl, delta)
# Update number of ancilla qubits
na = matrix_circuit.num_ancillas
else:
# Calculate breakpoints for the reciprocal approximation
num_values = 2**nl
constant = delta
a = int(round(num_values**(2 / 3))) # pylint: disable=invalid-name
# Calculate the degree of the polynomial and the number of intervals
r = 2 * constant / a + np.sqrt(np.abs(1 - (2 * constant / a)**2))
degree = min(
nb,
int(
np.log(1 +
(16.23 * np.sqrt(np.log(r)**2 +
(np.pi / 2)**2) * kappa *
(2 * kappa - self._epsilon_r)) / self._epsilon_r)))
num_intervals = int(
np.ceil(np.log((num_values - 1) / a) / np.log(5)))
# Calculate breakpoints and polynomials
breakpoints = []
for i in range(0, num_intervals):
# Add the breakpoint to the list
breakpoints.append(a * (5**i))
# Define the right breakpoint of the interval
if i == num_intervals - 1:
breakpoints.append(num_values - 1)
reciprocal_circuit = PiecewiseChebyshev(
lambda x: np.arcsin(constant / x), degree, breakpoints, nl)
na = max(matrix_circuit.num_ancillas,
reciprocal_circuit.num_ancillas)
# Initialise the quantum registers
qb = QuantumRegister(nb) # right hand side and solution
ql = QuantumRegister(nl) # eigenvalue evaluation qubits
if na > 0:
qa = AncillaRegister(na) # ancilla qubits
qf = QuantumRegister(nf) # flag qubits
if na > 0:
qc = QuantumCircuit(qb, ql, qa, qf)
else:
qc = QuantumCircuit(qb, ql, qf)
# State preparation
qc.append(vector_circuit, qb[:])
# QPE
phase_estimation = PhaseEstimation(nl, matrix_circuit)
if na > 0:
qc.append(phase_estimation,
ql[:] + qb[:] + qa[:matrix_circuit.num_ancillas])
else:
qc.append(phase_estimation, ql[:] + qb[:])
# Conditioned rotation
if self._exact_reciprocal:
qc.append(reciprocal_circuit, ql[::-1] + [qf[0]])
else:
qc.append(reciprocal_circuit.to_instruction(),
ql[:] + [qf[0]] + qa[:reciprocal_circuit.num_ancillas])
# QPE inverse
if na > 0:
qc.append(phase_estimation.inverse(),
ql[:] + qb[:] + qa[:matrix_circuit.num_ancillas])
else:
qc.append(phase_estimation.inverse(), ql[:] + qb[:])
return qc