def test_to_valid_density_matrix_size_mismatch_num_qubits():
with pytest.raises(ValueError, match='shape'):
cirq.to_valid_density_matrix(np.array([[[1, 0], [0, 0]],
[[0, 0], [0, 0]]]),
num_qubits=2)
with pytest.raises(ValueError, match='shape'):
cirq.to_valid_density_matrix(np.eye(4) / 4.0, num_qubits=1)
def test_to_valid_density_matrix_from_state_vector():
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=np.array(
[1, 0], dtype=np.complex64),
num_qubits=1),
np.array([[1, 0], [0, 0]]),
)
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(
density_matrix_rep=np.array(
[np.sqrt(0.3), np.sqrt(0.7)], dtype=np.complex64),
num_qubits=1,
),
np.array([[0.3, np.sqrt(0.3 * 0.7)], [np.sqrt(0.3 * 0.7), 0.7]]),
)
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(
density_matrix_rep=np.array(
[np.sqrt(0.5), np.sqrt(0.5) * 1j], dtype=np.complex64),
num_qubits=1,
),
np.array([[0.5, -0.5j], [0.5j, 0.5]]),
)
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=np.array(
[0.5] * 4, dtype=np.complex64),
num_qubits=2),
0.25 * np.ones((4, 4)),
)
def test_to_valid_density_matrix_not_positive_semidefinite():
with pytest.raises(ValueError, match='positive semidefinite'):
cirq.to_valid_density_matrix(
np.array([[1.1, 0], [0, -0.1]], dtype=np.complex64), num_qubits=1)
with pytest.raises(ValueError, match='positive semidefinite'):
cirq.to_valid_density_matrix(
np.array([[0.6, 0.5], [0.5, 0.4]], dtype=np.complex64),
num_qubits=1)
def test_sample_density_matrix_validate_qid_shape():
matrix = cirq.to_valid_density_matrix(0, 3)
cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 2))
with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 1))
matrix2 = cirq.to_valid_density_matrix(0, qid_shape=(1, 2, 3))
cirq.sample_density_matrix(matrix2, [], qid_shape=(1, 2, 3))
with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
cirq.sample_density_matrix(matrix2, [], qid_shape=(2, 2, 2))
def test_to_valid_density_matrix_not_hermitian():
with pytest.raises(ValueError, match='hermitian'):
cirq.to_valid_density_matrix(np.array([[0.5, 0.5j], [0.5, 0.5j]]),
num_qubits=1)
with pytest.raises(ValueError, match='hermitian'):
cirq.to_valid_density_matrix(np.array([[0.2, 0, 0, -0.2 - 0.3j],
[0, 0, 0, 0], [0, 0, 0, 0],
[0.2 + 0.3j, 0, 0, 0.8]]),
num_qubits=2)
def test_to_valid_density_matrix_from_computational_basis():
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=0, num_qubits=1),
np.array([[1, 0], [0, 0]]))
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=1, num_qubits=1),
np.array([[0, 0], [0, 1]]))
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=2, num_qubits=2),
np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]]))
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=0, num_qubits=0),
np.array([[1]]))
def test_to_valid_density_matrix_from_density_matrix_tensor():
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(cirq.one_hot(shape=(2, 2, 2, 2, 2, 2),
dtype=np.complex64),
num_qubits=3),
cirq.one_hot(shape=(8, 8), dtype=np.complex64),
)
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(cirq.one_hot(shape=(2, 3, 4, 2, 3, 4),
dtype=np.complex64),
qid_shape=(2, 3, 4)),
cirq.one_hot(shape=(24, 24), dtype=np.complex64),
)
def test_sample_density_matrix_partial_indices():
for index in range(3):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
np.testing.assert_equal(
cirq.sample_density_matrix(matrix, [index]),
[[bool(1 & (x >> (2 - index)))]])
def test_measure_density_matrix_partial_indices():
for index in range(3):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
bits, out_matrix = cirq.measure_density_matrix(matrix, [index])
np.testing.assert_almost_equal(out_matrix, matrix)
assert bits == [bool(1 & (x >> (2 - index)))]
def test_sample_density_matrix_partial_indices_all_orders():
for perm in itertools.permutations([0, 1, 2]):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
expected = [[bool(1 & (x >> (2 - p))) for p in perm]]
np.testing.assert_equal(cirq.sample_density_matrix(matrix, perm),
expected)
def test_decomposed_fallback():
class Composite(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _decompose_(self, qubits):
yield cirq.X(*qubits)
qid_shape = (2, )
tensor = cirq.to_valid_density_matrix(0,
len(qid_shape),
qid_shape=qid_shape,
dtype=np.complex64)
args = cirq.ActOnDensityMatrixArgs(
target_tensor=tensor,
available_buffer=[np.empty_like(tensor) for _ in range(3)],
qubits=cirq.LineQubit.range(1),
prng=np.random.RandomState(),
log_of_measurement_results={},
qid_shape=qid_shape,
)
cirq.act_on(Composite(), args, cirq.LineQubit.range(1))
np.testing.assert_allclose(
args.target_tensor,
cirq.one_hot(index=(1, 1), shape=(2, 2), dtype=np.complex64))
def test_validate_density_matrix():
cirq.validate_density_matrix(cirq.testing.random_density_matrix(2), qid_shape=(2,))
with pytest.raises(ValueError, match='dtype'):
cirq.to_valid_density_matrix(
np.array([[1, 0], [0, 0]], dtype=np.complex64), qid_shape=(2,), dtype=np.complex128
)
with pytest.raises(ValueError, match='shape'):
cirq.to_valid_density_matrix(np.array([[1, 0]]), qid_shape=(2,))
with pytest.raises(ValueError, match='hermitian'):
cirq.to_valid_density_matrix(np.array([[1, 0.1], [0, 0]]), qid_shape=(2,))
with pytest.raises(ValueError, match='trace 1'):
cirq.to_valid_density_matrix(np.array([[1, 0], [0, 0.1]]), qid_shape=(2,))
with pytest.raises(ValueError, match='positive semidefinite'):
cirq.to_valid_density_matrix(
np.array([[1.1, 0], [0, -0.1]], dtype=np.complex64), qid_shape=(2,)
)
def test_measure_density_matrix_partial_indices_all_orders():
for perm in itertools.permutations([0, 1, 2]):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
bits, out_matrix = cirq.measure_density_matrix(matrix, perm)
np.testing.assert_almost_equal(matrix, out_matrix)
assert bits == [bool(1 & (x >> (2 - p))) for p in perm]
def test_to_valid_density_matrix_from_state_vector_tensor():
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(density_matrix_rep=np.array(
np.full((2, 2), 0.5), dtype=np.complex64),
num_qubits=2),
0.25 * np.ones((4, 4)),
)
def _base_iterator(self,
circuit: circuits.Circuit,
qubit_order: ops.QubitOrderOrList,
initial_state: Union[int, np.ndarray],
perform_measurements: bool = True) -> Iterator:
qubits = ops.QubitOrder.as_qubit_order(qubit_order).order_for(
circuit.all_qubits())
num_qubits = len(qubits)
qubit_map = {q: i for i, q in enumerate(qubits)}
matrix = to_valid_density_matrix(initial_state,
num_qubits,
dtype=self._dtype)
if len(circuit) == 0:
yield DensityMatrixStepResult(matrix, {},
qubit_map,
dtype=self._dtype)
matrix = np.reshape(matrix, (2**num_qubits, 2**num_qubits))
noisy_moments = self.noise.noisy_moments(circuit,
sorted(circuit.all_qubits()))
state = qulacs.DensityMatrix(num_qubits)
state.load(matrix)
for moment in noisy_moments:
measurements = collections.defaultdict(
list) # type: Dict[str, List[bool]]
operations = moment.operations
for op in operations:
indices = [
num_qubits - 1 - qubit_map[qubit] for qubit in op.qubits
]
indices.reverse()
if isinstance(op, ops.MeasurementGate):
# Not implemented
raise NotImplementedError(
"Measurement is not supported in qulacs simulator")
else:
gate = cast(ops.GateOperation, op).gate
channel = protocols.channel(gate)
qulacs_gates = []
for krauss in channel:
krauss = krauss.astype(np.complex128)
qulacs_gate = qulacs.gate.DenseMatrix(indices, krauss)
qulacs_gates.append(qulacs_gate)
qulacs_cptp_map = qulacs.gate.CPTP(qulacs_gates)
qulacs_cptp_map.update_quantum_state(state)
matrix = state.get_matrix()
matrix = np.reshape(matrix, (2, ) * num_qubits * 2)
yield DensityMatrixStepResult(density_matrix=matrix,
measurements=measurements,
qubit_map=qubit_map,
dtype=self._dtype)
def test_sample_density_matrix_repetitions():
for perm in itertools.permutations([0, 1, 2]):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
expected = [[bool(1 & (x >> (2 - p))) for p in perm]] * 3
result = cirq.sample_density_matrix(matrix, perm, repetitions=3)
np.testing.assert_equal(result, expected)
def test_sample_density_matrix_no_repetitions():
matrix = cirq.to_valid_density_matrix(0, 3)
np.testing.assert_almost_equal(
cirq.sample_density_matrix(matrix, [1], repetitions=0),
np.zeros(shape=(0, 1)))
np.testing.assert_almost_equal(
cirq.sample_density_matrix(matrix, [0, 1], repetitions=0),
np.zeros(shape=(0, 2)))
def test_measure_state_no_indices_out_is_not_matrix():
matrix = cirq.to_valid_density_matrix(0, 3)
out = np.zeros_like(matrix)
bits, out_matrix = cirq.measure_density_matrix(matrix, [], out=out)
assert [] == bits
np.testing.assert_almost_equal(out_matrix, matrix)
assert out is out_matrix
assert out is not matrix
def test_to_valid_density_matrix_on_simulator_output(seed):
circuit = cirq.testing.random_circuit(qubits=5,
n_moments=20,
op_density=0.9,
random_state=seed)
simulator = cirq.DensityMatrixSimulator()
result = simulator.simulate(circuit)
_ = cirq.to_valid_density_matrix(result.final_density_matrix, num_qubits=5)
def assert_valid_density_matrix(matrix, num_qubits=None, qid_shape=None):
if qid_shape is None and num_qubits is None:
num_qubits = 1
np.testing.assert_almost_equal(
cirq.to_valid_density_matrix(matrix,
num_qubits=num_qubits,
qid_shape=qid_shape,
dtype=matrix.dtype), matrix)
def test_sample_density_matrix_big_endian():
results = []
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
sample = cirq.sample_density_matrix(matrix, [2, 1, 0])
results.append(sample)
expecteds = [[list(reversed(x))] for x in list(itertools.product([False, True], repeat=3))]
for result, expected in zip(results, expecteds):
np.testing.assert_equal(result, expected)
def test_shallow_copy_buffers():
qid_shape = (2, )
tensor = cirq.to_valid_density_matrix(0,
len(qid_shape),
qid_shape=qid_shape,
dtype=np.complex64)
args = cirq.ActOnDensityMatrixArgs(target_tensor=tensor)
copy = args.copy(deep_copy_buffers=False)
assert copy.available_buffer is args.available_buffer
def test_measure_density_matrix_computational_basis_reshaped():
results = []
for x in range(8):
matrix = np.reshape(cirq.to_valid_density_matrix(x, 3), (2,) * 6)
bits, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0])
results.append(bits)
np.testing.assert_almost_equal(out_matrix, matrix)
expected = [list(reversed(x)) for x in list(itertools.product([False, True], repeat=3))]
assert results == expected
def test_positional_argument():
qid_shape = (2,)
tensor = cirq.to_valid_density_matrix(
0, len(qid_shape), qid_shape=qid_shape, dtype=np.complex64
)
with cirq.testing.assert_deprecated(
'specify all the arguments with keywords', deadline='v0.15'
):
cirq.ActOnDensityMatrixArgs(tensor)
def test_to_valid_density_matrix_on_simulator_output(seed, dtype, split):
circuit = cirq.testing.random_circuit(qubits=5,
n_moments=20,
op_density=0.9,
random_state=seed)
simulator = cirq.DensityMatrixSimulator(split_untangled_states=split,
dtype=dtype)
result = simulator.simulate(circuit)
_ = cirq.to_valid_density_matrix(result.final_density_matrix,
num_qubits=5,
atol=1e-6)
def test_default_parameter():
qid_shape = (2, )
tensor = cirq.to_valid_density_matrix(0,
len(qid_shape),
qid_shape=qid_shape,
dtype=np.complex64)
args = cirq.ActOnDensityMatrixArgs(target_tensor=tensor)
assert len(args.available_buffer) == 3
for buffer in args.available_buffer:
assert buffer.shape == tensor.shape
assert buffer.dtype == tensor.dtype
assert args.qid_shape == qid_shape
def test_to_valid_density_matrix_mismatched_qid_shape():
with pytest.raises(ValueError, match=r'num_qubits != len\(qid_shape\)'):
cirq.to_valid_density_matrix(np.eye(4) / 4, num_qubits=1, qid_shape=(2, 2))
with pytest.raises(ValueError, match=r'num_qubits != len\(qid_shape\)'):
cirq.to_valid_density_matrix(np.eye(4) / 4, num_qubits=2, qid_shape=(4,))
with pytest.raises(ValueError, match='Both were None'):
cirq.to_valid_density_matrix(np.eye(4) / 4)
def test_to_valid_density_matrix_not_unit_trace():
with pytest.raises(ValueError, match='trace 1'):
cirq.to_valid_density_matrix(np.array([[1, 0], [0, 0.1]]), num_qubits=1)
with pytest.raises(ValueError, match='trace 1'):
cirq.to_valid_density_matrix(np.array([[1, 0], [0, -0.1]]),
num_qubits=1)
with pytest.raises(ValueError, match='trace 1'):
cirq.to_valid_density_matrix(np.zeros([2, 2]), num_qubits=1)
def test_default_parameter():
qid_shape = (2, )
tensor = cirq.to_valid_density_matrix(0,
len(qid_shape),
qid_shape=qid_shape,
dtype=np.complex64)
args = cirq.DensityMatrixSimulationState(qubits=cirq.LineQubit.range(1),
initial_state=0)
np.testing.assert_almost_equal(args.target_tensor, tensor)
assert len(args.available_buffer) == 3
for buffer in args.available_buffer:
assert buffer.shape == tensor.shape
assert buffer.dtype == tensor.dtype
assert args.qid_shape == qid_shape
def test_sample_density_matrix():
state = np.zeros(8, dtype=np.complex64)
state[0] = 1 / np.sqrt(2)
state[2] = 1 / np.sqrt(2)
matrix = cirq.to_valid_density_matrix(state, num_qubits=3)
for _ in range(10):
sample = cirq.sample_density_matrix(matrix, [2, 1, 0])
assert np.array_equal(sample, [[False, False, False]]) or np.array_equal(
sample, [[False, True, False]]
)
# Partial sample is correct.
for _ in range(10):
np.testing.assert_equal(cirq.sample_density_matrix(matrix, [2]), [[False]])
np.testing.assert_equal(cirq.sample_density_matrix(matrix, [0]), [[False]])
