def test_measurementsymbol_counter():
symbol1 = measurements.MeasurementSymbol(measurements.MeasurementResult((0, 1)))
symbol2 = measurements.MeasurementSymbol(measurements.MeasurementResult((1, 3)))
assert symbol1.result.qubits == (0, 1)
assert symbol2.result.qubits == (1, 3)
assert symbol1.name[0] == "m" # pylint: disable=E1101
assert symbol2.name[0] == "m" # pylint: disable=E1101
assert int(symbol1.name[1:]) + 3 == int(symbol2.name[1:]) # pylint: disable=E1101
def test_measurementsymbol_evaluate(backend):
result = measurements.MeasurementSymbol(measurements.MeasurementResult((0, 1)))
expr = 2 * result
with pytest.raises(NotImplementedError):
value = result.evaluate(expr)
result = measurements.MeasurementSymbol(measurements.MeasurementResult((0,)))
result.result.set_probabilities(np.array([0., 1.]), nshots=1)
expr = 2 * result
value = result.evaluate(expr)
assert value == 2
def test_measurementresult_conversions(backend, binary, dsamples, bsamples):
qubits = tuple(range(len(bsamples[0])))
result1 = measurements.MeasurementResult(qubits)
result1.decimal = K.cast(dsamples, dtype='DTYPEINT')
result2 = measurements.MeasurementResult(qubits)
result2.binary = K.cast(bsamples, dtype='DTYPEINT')
K.assert_allclose(result1.samples(binary=True), bsamples)
K.assert_allclose(result2.samples(binary=True), bsamples)
K.assert_allclose(result1.samples(binary=False), dsamples)
K.assert_allclose(result2.samples(binary=False), dsamples)
# test ``__getitem__``
for i, target in enumerate(dsamples):
K.assert_allclose(result1[i], target)
def test_measurementresult_apply_bitflips(backend, i, p0, p1):
result = measurements.MeasurementResult((0, 1, 2))
result.decimal = K.zeros(10, dtype='DTYPEINT')
K.set_seed(123)
noisy_result = result.apply_bitflips(p0, p1)
targets = K.test_regressions("test_measurementresult_apply_bitflips")
K.assert_allclose(noisy_result.samples(binary=False), targets[i])
def test_measurementregistersresult_frequencies(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
probs = np.random.random(16)
probs = probs / np.sum(probs)
result = measurements.MeasurementResult((0, 1, 2, 3),
probs,
nshots=1000000)
frequencies = result.frequencies()
qubits = {"a": (0, 1), "b": (2, 3)}
result = measurements.MeasurementRegistersResult(qubits, result)
register_frequencies = result.frequencies(registers=True)
assert register_frequencies.keys() == qubits.keys()
rkeys = ["00", "01", "10", "11"]
target_frequencies_a = {
k: sum(frequencies[f"{k}{l}"] for l in rkeys)
for k in rkeys
}
target_frequencies_b = {
k: sum(frequencies[f"{l}{k}"] for l in rkeys)
for k in rkeys
}
assert register_frequencies["a"] == target_frequencies_a
assert register_frequencies["b"] == target_frequencies_b
qibo.set_backend(original_backend)
def test_measurementresult_outcome(backend):
import collections
result = measurements.MeasurementResult((0, ))
result.decimal = K.zeros(1, dtype='DTYPEINT')
assert result.outcome() == 0
result.decimal = K.ones(1, dtype='DTYPEINT')
assert result.outcome() == 1
def test_measurementresult_frequencies(backend):
import collections
result = measurements.MeasurementResult((0, 1, 2))
result.decimal = K.cast([0, 6, 5, 3, 5, 5, 6, 1, 1, 2, 4], dtype='DTYPEINT')
dfreqs = {0: 1, 1: 2, 2: 1, 3: 1, 4: 1, 5: 3, 6: 2}
bfreqs = {"000": 1, "001": 2, "010": 1, "011": 1, "100": 1,
"101": 3, "110": 2}
assert result.frequencies(binary=True) == bfreqs
assert result.frequencies(binary=False) == dfreqs
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_measurementresult_errors():
"""Try to sample shots and frequencies without probability distribution."""
result = measurements.MeasurementResult((0, 1))
with pytest.raises(RuntimeError):
samples = result.samples()
with pytest.raises(RuntimeError):
samples = result.frequencies()
result.binary = np.random.randint(0, 2, (100, 2))
with pytest.raises(RuntimeError):
result.set_frequencies({0: 100})
def test_measurementresult_outcome(backend):
import collections
original_backend = qibo.get_backend()
qibo.set_backend(backend)
result = measurements.MeasurementResult((0, ))
result.decimal = np.zeros(1, dtype=np.int64)
assert result.outcome() == 0
result.decimal = np.ones(1, dtype=np.int64)
assert result.outcome() == 1
qibo.set_backend(original_backend)
def test_measurementresult_apply_bitflips_errors():
"""Check errors raised by `MeasurementResult.apply_bitflips`."""
result = measurements.MeasurementResult((0, 1, 3))
result.binary = np.random.randint(0, 2, (20, 3))
# Passing wrong qubit ids in bitflip error map
with pytest.raises(KeyError):
noisy_result = result.apply_bitflips({0: 0.1, 2: 0.2})
# Passing wrong bitflip error map type
with pytest.raises(TypeError):
noisy_result = result.apply_bitflips("test")
# Passing negative bitflip probability
with pytest.raises(ValueError):
noisy_result = result.apply_bitflips(-0.4)
def test_measurementregistersresult_samples(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
samples = np.random.randint(0, 2, (20, 4))
result = measurements.MeasurementResult((0, 1, 2, 3))
result.binary = 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()
np.testing.assert_allclose(register_samples["a"], samples[:, [0, 2]])
np.testing.assert_allclose(register_samples["b"], samples[:, [1, 3]])
qibo.set_backend(original_backend)
def test_measurementresult_add_shots(backend):
result = measurements.MeasurementResult((0, 1))
with pytest.raises(ValueError):
result.add_shot()
probs = np.array([1, 0, 0, 0], dtype=np.float64)
result.add_shot(probabilities=probs)
assert result.nshots == 1
K.assert_allclose(result.decimal, [0])
K.assert_allclose(result.binary, [[0, 0]])
probs = np.array([0, 0, 0, 1], dtype=np.float64)
result.add_shot(probabilities=probs)
assert result.nshots == 2
K.assert_allclose(result.decimal, [0, 3])
K.assert_allclose(result.binary, [[0, 0], [1, 1]])
def test_measurementresult_apply_bitflips_random_samples(backend, probs):
qubits = tuple(range(4))
samples = np.random.randint(0, 2, (20, 4))
result = measurements.MeasurementResult(qubits)
result.binary = K.cast(np.copy(samples))
K.set_seed(123)
noisy_result = result.apply_bitflips(probs)
K.set_seed(123)
if isinstance(probs, dict):
probs = np.array([probs[q] for q in qubits])
sprobs = K.to_numpy(K.random_uniform(samples.shape))
target_samples = (samples + (sprobs < probs)) % 2
K.assert_allclose(noisy_result.samples(), target_samples)
def test_measurementresult_apply_bitflips(backend, i, p0, p1):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
result = measurements.MeasurementResult((0, 1, 2))
result.decimal = K.zeros(10, dtype='DTYPEINT')
K.set_seed(123)
noisy_result = result.apply_bitflips(p0, p1)
if "numpy" in backend:
targets = [[0, 0, 0, 0, 2, 3, 0, 0, 0, 0],
[0, 0, 0, 0, 2, 3, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 2, 0, 0, 0, 0, 0]]
else:
targets = [[4, 0, 0, 1, 0, 2, 2, 4, 4, 0],
[4, 0, 0, 1, 0, 2, 2, 4, 4, 0],
[4, 0, 0, 1, 0, 0, 0, 4, 4, 0],
[4, 0, 0, 0, 0, 0, 0, 4, 4, 0]]
np.testing.assert_allclose(noisy_result.samples(binary=False), targets[i])
qibo.set_backend(original_backend)
def test_measurementresult_apply_bitflips_random_samples_asymmetric(backend):
qubits = tuple(range(4))
samples = np.random.randint(0, 2, (20, 4))
result = measurements.MeasurementResult(qubits)
result.binary = K.cast(np.copy(samples))
p1_map = {0: 0.2, 1: 0.0, 2: 0.0, 3: 0.1}
K.set_seed(123)
noisy_result = result.apply_bitflips(p0=0.2, p1=p1_map)
p0 = 0.2 * np.ones(4)
p1 = np.array([0.2, 0.0, 0.0, 0.1])
K.set_seed(123)
sprobs = K.to_numpy(K.random_uniform(samples.shape))
target_samples = np.copy(samples).ravel()
ids = (np.where(target_samples == 0)[0], np.where(target_samples == 1)[0])
target_samples[ids[0]] = samples.ravel()[ids[0]] + (sprobs < p0).ravel()[ids[0]]
target_samples[ids[1]] = samples.ravel()[ids[1]] - (sprobs < p1).ravel()[ids[1]]
target_samples = target_samples.reshape(samples.shape)
K.assert_allclose(noisy_result.samples(), target_samples)
def test_measurementresult_frequencies(backend):
import collections
original_backend = qibo.get_backend()
qibo.set_backend(backend)
result = measurements.MeasurementResult((0, 1, 2))
result.decimal = [0, 6, 5, 3, 5, 5, 6, 1, 1, 2, 4]
dfreqs = {0: 1, 1: 2, 2: 1, 3: 1, 4: 1, 5: 3, 6: 2}
bfreqs = {
"000": 1,
"001": 2,
"010": 1,
"011": 1,
"100": 1,
"101": 3,
"110": 2
}
assert result.frequencies(binary=True) == bfreqs
assert result.frequencies(binary=False) == dfreqs
qibo.set_backend(original_backend)
def test_measurementresult_apply_bitflips(backend, i, p0, p1):
result = measurements.MeasurementResult((0, 1, 2))
result.decimal = K.zeros(10, dtype='DTYPEINT')
K.set_seed(123)
noisy_result = result.apply_bitflips(p0, p1)
if K.name == "qibojit" and K.op.get_backend(
) == "cupy": # pragma: no cover
# cupy is not tested by CI!
targets = [[0, 0, 0, 6, 4, 1, 1, 4, 0, 2],
[0, 0, 0, 6, 4, 1, 1, 4, 0, 2],
[0, 0, 0, 0, 4, 1, 1, 4, 0, 0],
[0, 0, 0, 6, 4, 0, 0, 4, 0, 2]]
elif K.name == "numpy" or K.name == "qibojit":
targets = [[0, 0, 0, 0, 2, 3, 0, 0, 0, 0],
[0, 0, 0, 0, 2, 3, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 2, 0, 0, 0, 0, 0]]
else:
targets = [[4, 0, 0, 1, 0, 2, 2, 4, 4, 0],
[4, 0, 0, 1, 0, 2, 2, 4, 4, 0],
[4, 0, 0, 1, 0, 0, 0, 4, 4, 0],
[4, 0, 0, 0, 0, 0, 0, 4, 4, 0]]
K.assert_allclose(noisy_result.samples(binary=False), targets[i])
def set_measurements(self, qubits, samples, registers=None):
self.measurements = measurements.MeasurementResult(qubits)
self.measurements.decimal = samples
if registers is not None:
self.measurements = measurements.MeasurementRegistersResult(
registers, self.measurements)
def test_measurementresult_init():
result = measurements.MeasurementResult((0, 1))
assert result.qubits == (0, 1)
assert result.nqubits == 2
assert result.qubit_map == {0: 0, 1: 1}
