def test_vector_state_to_density_matrix(backend):
vector = np.random.random(32) + 1j * np.random.random(32)
vector = vector / np.sqrt((np.abs(vector) ** 2).sum())
state = states.VectorState.from_tensor(vector)
mstate = state.to_density_matrix()
target_matrix = np.outer(vector, vector.conj())
K.assert_allclose(mstate.tensor, target_matrix)
state = states.MatrixState.from_tensor(target_matrix)
with pytest.raises(RuntimeError):
state.to_density_matrix()
def test_cnot(backend, applyx):
if applyx:
gatelist = [gates.X(0)]
else:
gatelist = []
gatelist.append(gates.CNOT(0, 1))
final_state = apply_gates(gatelist, nqubits=2)
target_state = np.zeros_like(final_state)
target_state[3 * int(applyx)] = 1.0
K.assert_allclose(final_state, target_state)
def test_measurementregistersresult_samples(backend):
samples = np.random.randint(0, 2, (20, 4))
result = measurements.MeasurementResult((0, 1, 2, 3))
result.binary = K.cast(samples)
qubits = {"a": (0, 2), "b": (1, 3)}
result = measurements.MeasurementRegistersResult(qubits, result)
register_samples = result.samples(registers=True)
assert register_samples.keys() == qubits.keys()
K.assert_allclose(register_samples["a"], samples[:, [0, 2]])
K.assert_allclose(register_samples["b"], samples[:, [1, 3]])
def test_one_qubit_gates(backend, gatename, gatekwargs):
"""Check applying one qubit gates to one qubit density matrix."""
initial_rho = random_density_matrix(1)
gate = getattr(gates, gatename)(0, **gatekwargs)
gate.density_matrix = True
final_rho = gate(np.copy(initial_rho))
matrix = K.to_numpy(gate.matrix)
target_rho = np.einsum("ab,bc,cd->ad", matrix, initial_rho, matrix.conj().T)
K.assert_allclose(final_rho, target_rho)
def assert_result(result, decimal_samples=None, binary_samples=None,
decimal_frequencies=None, binary_frequencies=None):
if decimal_frequencies is not None:
assert result.frequencies(False) == decimal_frequencies
if binary_frequencies is not None:
assert result.frequencies(True) == binary_frequencies
if decimal_samples is not None:
K.assert_allclose(result.samples(False), decimal_samples)
if binary_samples is not None:
K.assert_allclose(result.samples(True), binary_samples)
def test_hgate_density_matrix(backend):
initial_rho = random_density_matrix(2)
gate = gates.H(1)
gate.density_matrix = True
final_rho = gate(np.copy(initial_rho))
matrix = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
matrix = np.kron(np.eye(2), matrix)
target_rho = matrix.dot(initial_rho).dot(matrix)
K.assert_allclose(final_rho, target_rho)
def test_state_probabilities(backend, state_type, use_gate):
state = getattr(states, state_type).plus_state(4)
if use_gate:
from qibo import gates
mgate = gates.M(0, 1)
probs = state.probabilities(measurement_gate=mgate)
else:
probs = state.probabilities(qubits=[0, 1])
target_probs = np.ones((2, 2)) / 4
K.assert_allclose(probs, target_probs)
def test_fuse_circuit_two_qubit_gates(backend):
"""Check circuit fusion in circuit with two-qubit gates only."""
c = Circuit(2)
c.add(gates.CNOT(0, 1))
c.add(gates.RX(0, theta=0.1234).controlled_by(1))
c.add(gates.SWAP(0, 1))
c.add(gates.fSim(1, 0, theta=0.1234, phi=0.324))
c.add(gates.RY(1, theta=0.1234).controlled_by(0))
fused_c = c.fuse()
K.assert_allclose(fused_c(), c())
def test_trotter_hamiltonian_scalar_mul(nqubits=3):
"""Test multiplication of Trotter Hamiltonian with scalar."""
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
target_ham = 2 * hamiltonians.TFIM(nqubits, h=1.0)
local_dense = (2 * local_ham).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
local_dense = (local_ham * 2).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
def test_trotter_hamiltonian_scalar_add(nqubits=4):
"""Test addition of Trotter Hamiltonian with scalar."""
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
target_ham = 2 + hamiltonians.TFIM(nqubits, h=1.0)
local_dense = (2 + local_ham).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
local_dense = (local_ham + 2).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
def test_controlled_x_vs_toffoli(backend):
c1 = Circuit(3)
c1.add(gates.X(0))
c1.add(gates.X(2))
c1.add(gates.X(1).controlled_by(0, 2))
c2 = Circuit(3)
c2.add(gates.X(0))
c2.add(gates.X(2))
c2.add(gates.TOFFOLI(0, 2, 1))
K.assert_allclose(c1(), c2())
def test_variational_layer_dagger(backend, nqubits):
theta = 2 * np.pi * np.random.random((2, nqubits))
pairs = list((i, i + 1) for i in range(0, nqubits - 1, 2))
gate = gates.VariationalLayer(range(nqubits), pairs, gates.RY, gates.CZ,
theta[0], theta[1])
c = Circuit(nqubits)
c.add((gate, gate.dagger()))
initial_state = random_state(nqubits)
final_state = c(np.copy(initial_state))
K.assert_allclose(final_state, initial_state)
def test_unitary_dagger(backend, nqubits):
matrix = np.random.random((2**nqubits, 2**nqubits))
gate = gates.Unitary(matrix, *range(nqubits))
c = Circuit(nqubits)
c.add((gate, gate.dagger()))
initial_state = random_state(nqubits)
final_state = c(np.copy(initial_state))
target_state = np.dot(matrix, initial_state)
target_state = np.dot(np.conj(matrix).T, target_state)
K.assert_allclose(final_state, target_state)
def test_controlled_unitary_dagger(backend):
from scipy.linalg import expm
matrix = np.random.random((2, 2))
matrix = expm(1j * (matrix + matrix.T))
gate = gates.Unitary(matrix, 0).controlled_by(1, 2, 3, 4)
c = Circuit(5)
c.add((gate, gate.dagger()))
initial_state = random_state(5)
final_state = c(np.copy(initial_state))
K.assert_allclose(final_state, initial_state)
def test_toffoli_gate(backend):
"""Check applying Toffoli to three qubit density matrix."""
initial_rho = random_density_matrix(3)
gate = gates.TOFFOLI(0, 1, 2)
gate.density_matrix = True
final_rho = gate(np.copy(initial_rho))
matrix = K.to_numpy(gate.matrix)
target_rho = np.einsum("ab,bc,cd->ad", matrix, initial_rho, matrix.conj().T)
K.assert_allclose(final_rho, target_rho)
def test_distributed_circuit_execution_special_gate(backend, accelerators):
dist_c = DistributedCircuit(6, accelerators)
initial_state = random_state(dist_c.nqubits)
dist_c.add(gates.Flatten(np.copy(initial_state)))
dist_c.add((gates.H(i) for i in range(dist_c.nlocal)))
dist_c.global_qubits = range(dist_c.nlocal, dist_c.nqubits)
c = Circuit(6)
c.add(gates.Flatten(np.copy(initial_state)))
c.add((gates.H(i) for i in range(dist_c.nlocal)))
K.assert_allclose(dist_c(), c())
def test_entropy_switch_partition(backend):
"""Check that partition is switched to the largest counterpart."""
entropy = callbacks.EntanglementEntropy([0])
# Prepare ghz state of 5 qubits
state = np.zeros(2 ** 5)
state[0], state[-1] = 1, 1
state = state / np.sqrt(2)
result = entropy(K.cast(state))
K.assert_allclose(result, 1.0)
def test_trotter_hamiltonian_scalar_sub(nqubits=3):
"""Test subtraction of Trotter Hamiltonian with scalar."""
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
target_ham = 2 - hamiltonians.TFIM(nqubits, h=1.0)
local_dense = (2 - local_ham).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
target_ham = hamiltonians.TFIM(nqubits, h=1.0) - 2
local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)
local_dense = (local_ham - 2).dense
K.assert_allclose(local_dense.matrix, target_ham.matrix)
def test_overlap(backend, density_matrix):
state0 = np.random.random(4) + 1j * np.random.random(4)
state1 = np.random.random(4) + 1j * np.random.random(4)
overlap = callbacks.Overlap(state0)
if density_matrix:
overlap.density_matrix = True
with pytest.raises(NotImplementedError):
overlap(state1)
else:
target_overlap = np.abs((state0.conj() * state1).sum())
K.assert_allclose(overlap(K.cast(state1)), target_overlap)
def test_norm(backend, density_matrix):
norm = callbacks.Norm()
if density_matrix:
norm.density_matrix = True
state = np.random.random((2, 2)) + 1j * np.random.random((2, 2))
target_norm = np.trace(state)
else:
state = np.random.random(4) + 1j * np.random.random(4)
target_norm = np.sqrt((np.abs(state) ** 2).sum())
K.assert_allclose(norm(K.cast(state)), target_norm)
def test_controlled_by_gates_fusion(backend):
"""Check circuit fusion that contains ``controlled_by`` gates."""
c = Circuit(4)
c.add((gates.H(i) for i in range(4)))
c.add(gates.RX(1, theta=0.1234).controlled_by(0))
c.add(gates.RX(3, theta=0.4321).controlled_by(2))
c.add((gates.RY(i, theta=0.5678) for i in range(4)))
c.add(gates.RX(1, theta=0.1234).controlled_by(0))
c.add(gates.RX(3, theta=0.4321).controlled_by(2))
fused_c = c.fuse()
K.assert_allclose(fused_c(), c())
def test_hamiltonian_ground_state(sparse_type, dense):
"""Test Hamiltonian ground state."""
if sparse_type is None:
H = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
else:
from scipy import sparse
H = hamiltonians.XXZ(nqubits=5, delta=0.5)
m = getattr(sparse, f"{sparse_type}_matrix")(K.to_numpy(H.matrix))
H = hamiltonians.Hamiltonian(5, m)
V = K.to_numpy(H.eigenvectors())
K.assert_allclose(H.ground_state(), V[:, 0])
def test_final_state_property(backend):
"""Check accessing final state using the circuit's property."""
c = Circuit(2)
c.add([gates.H(0), gates.H(1)])
with pytest.raises(RuntimeError):
final_state = c.final_state
_ = c()
target_state = np.ones(4) / 2
K.assert_allclose(c.final_state, target_state)
def test_circuit_unitary(backend):
from qibo import matrices
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.CNOT(0, 1))
c.add(gates.X(0))
c.add(gates.Y(1))
h = np.kron(matrices.H, matrices.H)
target_matrix = np.kron(matrices.X, matrices.Y) @ matrices.CNOT @ h
K.assert_allclose(c.unitary(), target_matrix)
def test_generalizedfsim_dagger(backend):
from scipy.linalg import expm
phi = 0.2
matrix = np.random.random((2, 2))
matrix = expm(1j * (matrix + matrix.T))
gate = gates.GeneralizedfSim(0, 1, matrix, phi)
c = Circuit(2)
c.add((gate, gate.dagger()))
initial_state = random_state(2)
final_state = c(np.copy(initial_state))
K.assert_allclose(final_state, initial_state)
def test_pauli_noise_channel(backend):
initial_rho = random_density_matrix(2)
gate = gates.PauliNoiseChannel(1, px=0.3)
gate.density_matrix = True
final_rho = gate(K.cast(np.copy(initial_rho)))
gate = gates.X(1)
gate.density_matrix = True
initial_rho = K.cast(initial_rho)
target_rho = 0.3 * gate(K.copy(initial_rho))
target_rho += 0.7 * initial_rho
K.assert_allclose(final_rho, target_rho)
def test_variational_layer(backend, nqubits):
theta = 2 * np.pi * np.random.random(nqubits)
gatelist = [gates.RY(i, t) for i, t in enumerate(theta)]
gatelist.extend(gates.CZ(i, i + 1) for i in range(0, nqubits - 1, 2))
target_state = apply_gates(gatelist, nqubits=nqubits)
pairs = list((i, i + 1) for i in range(0, nqubits - 1, 2))
gate = gates.VariationalLayer(range(nqubits), pairs, gates.RY, gates.CZ,
theta)
final_state = apply_gates([gate], nqubits=nqubits)
K.assert_allclose(target_state, final_state)
def test_vector_state_expectation(backend, dense):
from qibo.hamiltonians import XXZ
ham = XXZ(nqubits=5, delta=0.5, dense=dense)
matrix = K.to_numpy(ham.matrix)
state = np.random.random(32) + 1j * np.random.random(32)
norm = np.sum(np.abs(state)**2)
target_ev = np.sum(state.conj() * matrix.dot(state)).real
state = states.VectorState.from_tensor(state)
K.assert_allclose(state.expectation(ham), target_ev)
K.assert_allclose(state.expectation(ham, True), target_ev / norm)
def test_hamiltonian_term_merge(backend):
"""Test ``HamiltonianTerm.merge``."""
matrix1 = np.random.random((2, 2))
matrix2 = np.random.random((4, 4))
term1 = terms.HamiltonianTerm(matrix1, 1)
term2 = terms.HamiltonianTerm(matrix2, 0, 1)
mterm = term2.merge(term1)
target_matrix = np.kron(np.eye(2), matrix1) + matrix2
assert mterm.target_qubits == (0, 1)
K.assert_allclose(mterm.matrix, target_matrix)
with pytest.raises(ValueError):
term1.merge(term2)
def test_unitary_initialization(backend):
matrix = np.random.random((4, 4))
gate = gates.Unitary(matrix, 0, 1)
K.assert_allclose(gate.parameters, matrix)
matrix = np.random.random((8, 8))
with pytest.raises(ValueError):
gate = gates.Unitary(matrix, 0, 1)
with pytest.raises(TypeError):
gate = gates.Unitary("abc", 0, 1)
if K.op is not None:
with pytest.raises(NotImplementedError):
gate = gates.Unitary(matrix, 0, 1, 2)
