示例#1
0
def test_observable_expectation_from_measurements_two_pauli_strings():
    obs = Observable(PauliString(spec="Z", coeff=2.5), PauliString(spec="X"))

    bits = MeasurementResult([[0], [0], [0], [0], [0], [0], [0], [0], [0],
                              [0]])
    expectation = obs._expectation_from_measurements([bits, bits])
    assert np.isclose(expectation, 3.5)
示例#2
0
def test_observable_expectation_one_circuit(n, executor):
    executor = functools.partial(executor, noise_level=(0, ))

    qubits = cirq.LineQubit.range(n)
    obs = Observable(PauliString(spec="X" * n))
    circuit = cirq.Circuit(cirq.H.on_each(qubits))

    expectation = obs.expectation(circuit, executor)
    assert np.isclose(expectation, 1.0)
示例#3
0
def test_observable_expectation_two_circuits(n, executor):
    executor = functools.partial(executor, noise_level=(0, ))

    obs = Observable(PauliString(spec="X" * n, coeff=-2.0),
                     PauliString(spec="Z" * n))
    qubits = cirq.LineQubit.range(n)
    circuit = cirq.Circuit(cirq.H.on_each(qubits))

    expectation = obs.expectation(circuit, executor)
    assert np.isclose(expectation, -2.0, atol=1e-1)
示例#4
0
def test_observable_partition_single_qubit_paulis():
    x = PauliString(spec="X")
    y = PauliString(spec="Y")
    z = PauliString(spec="Z")
    obs = Observable(x, y, z)
    assert obs.nterms == 3

    obs.partition(seed=2)
    expected_groups = [
        PauliStringCollection(x),
        PauliStringCollection(y),
        PauliStringCollection(z),
    ]
    assert obs.groups == expected_groups
示例#5
0
def test_observable():
    pauli1 = PauliString(spec="XI", coeff=-1.0)
    pauli2 = PauliString(spec="IZ", coeff=2.0)
    obs = Observable(pauli1, pauli2)

    assert obs.nqubits == 2
    assert obs.qubit_indices == [0, 1]
    assert obs.nterms == 2
    assert obs.ngroups == 1

    assert str(obs) == "-X(0) + (2+0j)*Z(1)"

    correct_matrix = -1.0 * np.kron(xmat, imat) + 2.0 * np.kron(imat, zmat)
    assert np.allclose(obs.matrix(), correct_matrix)
示例#6
0
def test_observable_expectation_from_measurements_one_pauli_string():
    obs = Observable(PauliString(spec="Z"))

    measurements = MeasurementResult([[0], [0], [0], [0], [0], [0], [0], [0],
                                      [0], [0]])
    expectation = obs._expectation_from_measurements([measurements])
    assert np.isclose(expectation, 1.0)

    measurements = MeasurementResult([[1], [1], [1], [1], [1], [1], [1], [1],
                                      [1], [1]])
    expectation = obs._expectation_from_measurements([measurements])
    assert np.isclose(expectation, -1.0)

    measurements = MeasurementResult([[0], [1], [0], [1], [0], [1], [0], [1],
                                      [0], [1]])
    expectation = obs._expectation_from_measurements([measurements])
    assert np.isclose(expectation, 0.0)
示例#7
0
def test_observable_partition_one_set():
    pauli1 = PauliString(spec="ZI")
    pauli2 = PauliString(spec="IZ")
    pauli3 = PauliString(spec="ZZ")
    obs = Observable(pauli1, pauli2, pauli3)
    assert obs.nterms == 3

    assert obs.ngroups == 1
    assert obs.groups[0] == PauliStringCollection(pauli1, pauli2, pauli3)
示例#8
0
def test_observable_measure_in_needs_one_circuit_x():
    pauli1 = PauliString(spec="XI")
    pauli2 = PauliString(spec="IX")
    pauli3 = PauliString(spec="XX")
    obs = Observable(pauli1, pauli2, pauli3)

    qubits = cirq.LineQubit.range(2)
    circuit = cirq.testing.random_circuit(qubits, 3, 1, random_state=1)

    measures_obs_circuits = obs.measure_in(circuit)
    assert len(measures_obs_circuits) == 1

    expected = circuit + xrotation.on_each(*qubits) + cirq.measure(*qubits)
    assert _equal(
        measures_obs_circuits[0],
        expected,
        require_qubit_equality=True,
        require_measurement_equality=True,
    )
示例#9
0
def test_observable_measure_in_needs_two_circuits():
    obs = Observable(PauliString(spec="X"), PauliString(spec="Z"))

    q = cirq.LineQubit(0)
    circuit = cirq.Circuit(cirq.H.on(q))

    measures_obs_circuits = sorted(obs.measure_in(circuit), key=len)
    assert len(measures_obs_circuits) == 2

    expected_circuits = [
        circuit + cirq.measure(q),
        circuit + xrotation.on(q) + cirq.measure(q),
    ]
    for expected, measured in zip(expected_circuits, measures_obs_circuits):
        assert _equal(
            measured,
            expected,
            require_qubit_equality=True,
            require_measurement_equality=True,
        )
示例#10
0
def test_observable_expectation_supported_qubits(executor):
    executor = functools.partial(executor, noise_level=(0, ))

    a, b, c = cirq.LineQubit.range(3)
    circuit = cirq.Circuit(cirq.I(a), cirq.X.on(b), cirq.H.on(c))

    # <Z0> = 1.
    obs = Observable(PauliString(spec="Z", support=(0, )))
    assert np.isclose(obs.expectation(circuit, executor), 1.0)

    # <Z1> = -1.
    obs = Observable(PauliString(spec="Z", support=(1, )))
    assert np.isclose(obs.expectation(circuit, executor), -1.0)

    # <Z2> = 0.
    obs = Observable(PauliString(spec="Z", support=(2, )))
    assert np.isclose(obs.expectation(circuit, executor), 0.0, atol=5e-2)
示例#11
0
def test_observable_from_pauli_string_collections():
    z = PauliString("Z")
    zz = PauliString("ZZ")
    pcol1 = PauliStringCollection(z, zz)
    x = PauliString("X")
    xx = PauliString("XX")
    pcol2 = PauliStringCollection(x, xx)

    obs = Observable.from_pauli_string_collections(pcol1, pcol2)
    assert obs.ngroups == 2
    assert obs.groups[0] == pcol1
    assert obs.groups[1] == pcol2
    assert obs.nterms == 4
示例#12
0
def test_observable_partition_can_be_measured_with():
    n = 10
    nterms = 50
    rng = np.random.RandomState(seed=1)
    obs = Observable(*[
        PauliString(spec=rng.choice(
            ("I", "X", "Y", "Z"),
            size=n,
            replace=True,
            p=(0.7, 0.1, 0.1, 0.1),
        )) for _ in range(nterms)
    ])

    assert obs.nqubits == n
    assert obs.nterms == nterms
    assert obs.ngroups <= nterms

    for pset in obs.groups:
        pauli_list = list(pset.elements)
        for i in range(len(pauli_list) - 1):
            for j in range(i, len(pauli_list)):
                assert pauli_list[i].can_be_measured_with(pauli_list[j])