def result():
qml.PauliX(0)
qml.PauliX(2)
qml.SingleExcitation(0.1, wires=[0, 1])
qml.SingleExcitation(0.2, wires=[2, 3])
qml.SingleExcitation(0.3, wires=[1, 2])
return qml.expval(qml.SparseHamiltonian(h, wires=[0, 1, 2, 3]))
def circuit():
qml.RX(0.4, wires=[0])
qml.RY(-0.2, wires=[1])
return qml.expval(
qml.SparseHamiltonian(qml.utils.sparse_hamiltonian(
qml.Hamiltonian([1], [cases[0]])),
wires=[0, 1]))
def test_sparse_matrix(self, sparse_hamiltonian, tol):
"""Test that the matrix property of the SparseHamiltonian class returns the correct matrix."""
num_wires = len(sparse_hamiltonian[0])
sparse_hamiltonian = coo_matrix(sparse_hamiltonian)
returned_matrix = qml.SparseHamiltonian(sparse_hamiltonian, range(num_wires)).matrix
assert np.allclose(
returned_matrix.toarray(), sparse_hamiltonian.toarray(), atol=tol, rtol=0
)
def test_sparse_diagonalization(self, sparse_hamiltonian):
"""Test that the diagonalizing_gates property of the SparseHamiltonian class returns empty."""
num_wires = len(sparse_hamiltonian[0])
sparse_hamiltonian = coo_matrix(sparse_hamiltonian)
diag_gates = qml.SparseHamiltonian(
sparse_hamiltonian, range(num_wires)
).diagonalizing_gates()
assert diag_gates == []
def test_sparse_expval_error(self):
"""Test that a DeviceError is raised when the observable is SparseHamiltonian and finite
shots is requested."""
hamiltonian = coo_matrix(np.array([[1.0, 0.0], [0.0, 1.0]]))
dev = qml.device("default.qubit", wires=1, shots=1)
with pytest.raises(DeviceError, match="SparseHamiltonian must be used with shots=None"):
dev.expval(qml.SparseHamiltonian(hamiltonian, [0]))[0]
def circuit_default():
qml.BasisState(hf_state, wires=range(qubits))
for i, excitation in enumerate(excitations):
if len(excitation) == 4:
qml.DoubleExcitation(1, wires=excitation)
elif len(excitation) == 2:
qml.SingleExcitation(1, wires=excitation)
return qml.expval(qml.SparseHamiltonian(H_sparse, wires=wires))
def test_sparse_hamiltonian_expval(self, qubits, operations, hamiltonian, expected_output, tol):
"""Test that expectation values of sparse hamiltonians are properly calculated."""
hamiltonian = coo_matrix(hamiltonian)
dev = qml.device("default.qubit", wires=qubits, shots=None)
dev.apply(operations)
expval = dev.expval(qml.SparseHamiltonian(hamiltonian, range(qubits)))[0]
assert np.allclose(expval, expected_output, atol=tol, rtol=0)
"Identity":
qml.Identity(wires=[0]),
"Hadamard":
qml.Hadamard(wires=[0]),
"Hermitian":
qml.Hermitian(np.eye(2), wires=[0]),
"PauliX":
qml.PauliX(wires=[0]),
"PauliY":
qml.PauliY(wires=[0]),
"PauliZ":
qml.PauliZ(wires=[0]),
"Projector":
qml.Projector(np.array([1]), wires=[0]),
"SparseHamiltonian":
qml.SparseHamiltonian(coo_matrix(np.eye(8)), wires=[0, 1, 2]),
"Hamiltonian":
qml.Hamiltonian([1, 1], [qml.PauliZ(0), qml.PauliX(0)]),
}
all_obs = obs.keys()
# All qubit observables should be available to test in the device test suite
all_available_obs = qml.ops._qubit__obs__.copy() # pylint: disable=protected-access
# Note that the identity is not technically a qubit observable
all_available_obs |= {"Identity"}
if not set(all_obs) == all_available_obs:
raise ValueError(
"A qubit observable has been added that is not being tested in the "
"device test suite. Please add to the obs dictionary in "
def circuit(sparse_hamiltonian, num_wires):
obs = qml.SparseHamiltonian(sparse_hamiltonian, range(num_wires))
return qml.expval(obs)
def circuit(param):
qml.PauliX(0)
qml.PauliX(1)
qml.DoubleExcitation(param, wires=[0, 1, 2, 3])
return qml.expval(qml.SparseHamiltonian(hamiltonian, wires=range(qubits)))
def circuit(param):
qml.RX(param, wires=0)
return qml.expval(qml.SparseHamiltonian(coo_matrix(np.eye(4)), [0, 1]))
