def test_sympy_scope_simulation():
q0, q1, q2, q3, q_ignored, q_result = cirq.LineQubit.range(6)
condition = sympy_parser.parse_expr('a & b | c & d')
# We set up condition (a & b | c & d) plus an ignored measurement key, and run through the
# combinations of possible values of those (by doing X(q_i)**bits[i] on each), then verify
# that the final measurement into m_result is True iff that condition was met.
for i in range(32):
bits = cirq.big_endian_int_to_bits(i, bit_count=5)
inner = cirq.Circuit(
cirq.X(q0)**bits[0],
cirq.measure(q0, key='a'),
cirq.X(q_result).with_classical_controls(condition),
cirq.measure(q_result, key='m_result'),
)
middle = cirq.Circuit(
cirq.X(q1)**bits[1],
cirq.measure(q1, key='b'),
cirq.X(q_ignored)**bits[4],
cirq.measure(q_ignored, key=cirq.MeasurementKey('c', ('0', ))),
cirq.CircuitOperation(inner.freeze(), repetition_ids=['0']),
)
circuit = cirq.Circuit(
cirq.X(q2)**bits[2],
cirq.measure(q2, key='c'),
cirq.X(q3)**bits[3],
cirq.measure(q3, key='d'),
cirq.CircuitOperation(middle.freeze(), repetition_ids=['0']),
)
result = cirq.CliffordSimulator().run(circuit)
assert result.measurements['0:0:m_result'][0][0] == (
bits[0] and bits[1] or bits[2] and bits[3] # bits[4] irrelevant
)
def to_cirq_result(
self,
params: Optional[cirq.ParamResolver] = None,
) -> cirq.Result:
"""Returns a `cirq.Result` for these results.
`cirq.Result` contains a less dense representation of results than that returned by
the IonQ API. Typically these results are also ordered by when they were run, though
that contract is implicit. Because the IonQ API does not retain that ordering information,
the order of these `cirq.Result` objects should *not* be interpetted as representing the
order in which the circuit was repeated.
Args:
params: The `cirq.ParamResolver` used to generate these results.
Returns:
The `cirq.Result` for these results.
Raises:
ValueError: If the circuit used to produce this result had no measurement gates
(and hence no measurement keys).
"""
if len(self.measurement_dict()) == 0:
raise ValueError(
'Can convert to cirq results only if the circuit had measurement gates '
'with measurement keys.')
measurements = {}
for key, targets in self.measurement_dict().items():
qpu_results = list(self.counts(key).elements())
measurements[key] = np.array(
list(
cirq.big_endian_int_to_bits(x, bit_count=len(targets))
for x in qpu_results))
return cirq.Result(params=params or cirq.ParamResolver({}),
measurements=measurements)
def _pretty_str_dict(value: dict, bit_count: int) -> str:
"""Pretty prints a dict, converting int dict values to bit strings."""
strs = []
for k, v in value.items():
bits = ''.join(str(b) for b in cirq.big_endian_int_to_bits(k, bit_count=bit_count))
strs.append(f'{bits}: {v}')
return '\n'.join(strs)
def test_sympy():
q0, q1, q2, q3, q_result = cirq.LineQubit.range(5)
for i in range(4):
for j in range(4):
# Put first two qubits into a state representing bitstring(i), next two qubits into a
# state representing bitstring(j) and measure those into m_i and m_j respectively. Then
# add a conditional X(q_result) based on m_i > m_j and measure that.
bitstring_i = cirq.big_endian_int_to_bits(i, bit_count=2)
bitstring_j = cirq.big_endian_int_to_bits(j, bit_count=2)
circuit = cirq.Circuit(
cirq.X(q0)**bitstring_i[0],
cirq.X(q1)**bitstring_i[1],
cirq.X(q2)**bitstring_j[0],
cirq.X(q3)**bitstring_j[1],
cirq.measure(q0, q1, key='m_i'),
cirq.measure(q2, q3, key='m_j'),
cirq.X(q_result).with_classical_controls(
sympy_parser.parse_expr('m_j > m_i')),
cirq.measure(q_result, key='m_result'),
)
# m_result should now be set iff j > i.
result = cirq.Simulator().run(circuit)
assert result.measurements['m_result'][0][0] == (j > i)
def inner_product_of_state_and_x(self, x: int) -> Union[float, complex]:
""" Returns the amplitude of x'th element of
the wavefunction, i.e. <x|psi> """
if type(x) == int:
y = cirq.big_endian_int_to_bits(x, bit_count=self.n)
mu = sum(y * self.gamma)
u = np.zeros(self.n, dtype=bool)
for p in range(self.n):
if y[p]:
u ^= self.F[p, :]
mu += 2 * (sum(self.M[p, :] & u) % 2)
return self.omega * 2**(-sum(self.v) / 2) * 1j**mu * (
-1)**sum(self.v & u & self.s) * np.all(self.v | (u == self.s))
def assert_equivalent_to_deferred(circuit: cirq.Circuit):
qubits = list(circuit.all_qubits())
sim = cirq.Simulator()
num_qubits = len(qubits)
for i in range(2**num_qubits):
bits = cirq.big_endian_int_to_bits(i, bit_count=num_qubits)
modified = cirq.Circuit()
for j in range(num_qubits):
if bits[j]:
modified.append(cirq.X(qubits[j]))
modified.append(circuit)
deferred = cirq.defer_measurements(modified)
result = sim.simulate(modified)
result1 = sim.simulate(deferred)
np.testing.assert_equal(result.measurements, result1.measurements)
def _little_endian_to_big(value: int, bit_count: int) -> int:
return cirq.big_endian_bits_to_int(
cirq.big_endian_int_to_bits(value, bit_count=bit_count)[::-1])
def test_big_endian_int_to_bits():
assert cirq.big_endian_int_to_bits(2, bit_count=4) == [0, 0, 1, 0]
assert cirq.big_endian_int_to_bits(
18, bit_count=8) == [0, 0, 0, 1, 0, 0, 1, 0]
assert cirq.big_endian_int_to_bits(18, bit_count=4) == [0, 0, 1, 0]
assert cirq.big_endian_int_to_bits(-3, bit_count=4) == [1, 1, 0, 1]
