def test_z_h_act_on_tableau():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.Z, DummyActOnArgs(), qubits=())
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.H, DummyActOnArgs(), qubits=())
original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 0.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 0.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 3.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 3.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.Z ** 2, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.H ** 2, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
foo = sympy.Symbol('foo')
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.Z ** foo, args, [cirq.LineQubit(1)])
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.H ** foo, args, [cirq.LineQubit(1)])
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.H ** 1.5, args, [cirq.LineQubit(1)])
def test_sympy_path_prefix():
q = cirq.LineQubit(0)
op = cirq.X(q).with_classical_controls(sympy.Symbol('b'))
prefixed = cirq.with_key_path_prefix(op, ('0', ))
assert cirq.control_keys(prefixed) == {'0:b'}
def test_make_experiment_no_rots():
exp = cirq.experiments.StateTomographyExperiment(
[cirq.LineQubit(0),
cirq.LineQubit(1),
cirq.LineQubit(2)])
assert len(exp.rot_sweep) > 0
def test_stratify_respects_no_compile_operations():
q1, q2, q3, q4, q5 = cirq.LineQubit.range(5)
input_circuit = cirq.Circuit(
cirq.Moment([
cirq.X(q1).with_tags("nocompile"),
cirq.ISWAP(q2, q3).with_tags("nocompile"),
cirq.Z(q5),
]),
cirq.Moment([cirq.X(q1), cirq.ISWAP(q4, q5)]),
cirq.Moment([cirq.ISWAP(q1, q2), cirq.X(q4)]),
)
expected = cirq.Circuit([
cirq.Moment(
cirq.TaggedOperation(cirq.X(cirq.LineQubit(0)), 'nocompile'),
cirq.TaggedOperation(
cirq.ISWAP(cirq.LineQubit(1), cirq.LineQubit(2)), 'nocompile'),
),
cirq.Moment(cirq.X(cirq.LineQubit(0)), ),
cirq.Moment(cirq.Z(cirq.LineQubit(4)), ),
cirq.Moment(
cirq.ISWAP(cirq.LineQubit(3), cirq.LineQubit(4)),
cirq.ISWAP(cirq.LineQubit(0), cirq.LineQubit(1)),
),
cirq.Moment(cirq.X(cirq.LineQubit(3)), ),
])
cirq.testing.assert_has_diagram(
input_circuit,
'''
0: ───X['nocompile']───────X───────iSwap───
│
1: ───iSwap['nocompile']───────────iSwap───
│
2: ───iSwap────────────────────────────────
3: ────────────────────────iSwap───X───────
│
4: ───Z────────────────────iSwap───────────
''',
)
cirq.testing.assert_has_diagram(
expected,
'''
0: ───X['nocompile']───────X───────iSwap───────
│
1: ───iSwap['nocompile']───────────iSwap───────
│
2: ───iSwap────────────────────────────────────
3: ────────────────────────────────iSwap───X───
│
4: ────────────────────────────Z───iSwap───────
''',
)
cirq.testing.assert_same_circuits(
cirq.stratified_circuit(
input_circuit,
categories=[cirq.X, cirq.Z],
context=cirq.TransformerContext(tags_to_ignore=("nocompile", )),
),
expected,
)
def test_str():
q0 = cirq.LineQubit(0)
op = cirq.X(q0).with_classical_controls('a')
assert str(op) == 'X(0).with_classical_controls(a)'
def test_wrapper_repr():
q0 = cirq.LineQubit(0)
node = cirq.CircuitDag.make_node(cirq.X(q0))
assert (repr(node) == 'cirq.Unique(' + str(id(node)) +
', cirq.X(cirq.LineQubit(0)))')
Author: Logan Mayfield Date: 11/5/2018 Implementation of Hello Quantum Level 2, Puzzle 4 and it's solution. This script also demonstrates a few different ways of simulating and analyzing the circuit """ import cirq as cq import numpy as np import hqAnalysis.hqhelp as hh #%% # Create a 2 qubit register qubits = cq.LineQubit(0).range(2) # create an empty circuit circuit = cq.Circuit() # construct a simulator to run the circuit sim = cq.google.XmonSimulator() #%% ## The indexing of lineQubits is such that the high-order bit (top wire) is ## index 0. ## initialize starting state to |11> circuit.append(cq.H(qubits[1]))
def test_cannot_remap_non_measurement_gate():
a = cirq.LineQubit(0)
op = cirq.X(a)
assert cirq.with_measurement_key_mapping(op, {'m': 'k'}) is NotImplemented
def test_is_clifford_with_nonclifford(circuit_type):
circuit = convert_from_mitiq(cirq.Circuit(cirq.T.on(cirq.LineQubit(0))),
circuit_type)
assert not is_clifford(circuit)
def test_op_identifier():
op_id = OpIdentifier(cirq.XPowGate)
assert cirq.X(cirq.LineQubit(1)) in op_id
assert cirq.Rx(rads=1) in op_id
def test_equal_up_to_global_phase_on_diff_types():
op = cirq.X(cirq.LineQubit(0))
assert not cirq.equal_up_to_global_phase(op, 3)
def test_deprecated_operations_parameter():
op = cirq.X(cirq.LineQubit(0))
with cirq.testing.assert_logs('Don\'t specify a keyword.'):
# pylint: disable=unexpected-keyword-arg
m = cirq.Moment(operations=[op])
assert m == cirq.Moment(op)
def test_init2():
with pytest.raises(ValueError, match=r'len\(control_values\) != num_controls'):
cirq.ControlledGate(cirq.Z, num_controls=1, control_values=(1, 0))
with pytest.raises(ValueError, match=r'len\(control_qid_shape\) != num_controls'):
cirq.ControlledGate(cirq.Z, num_controls=1, control_qid_shape=(2, 2))
with pytest.raises(ValueError, match='Control values .*outside of range'):
cirq.ControlledGate(cirq.Z, control_values=[2])
with pytest.raises(ValueError, match='Control values .*outside of range'):
cirq.ControlledGate(cirq.Z, control_values=[(1, -1)])
with pytest.raises(ValueError, match='Control values .*outside of range'):
cirq.ControlledGate(cirq.Z, control_values=[3], control_qid_shape=[3])
gate = cirq.ControlledGate(cirq.Z, 1)
assert gate.sub_gate is cirq.Z
assert gate.num_controls() == 1
assert gate.control_values == ((1,),)
assert gate.control_qid_shape == (2,)
assert gate.num_qubits() == 2
assert cirq.qid_shape(gate) == (2, 2)
gate = cirq.ControlledGate(cirq.Z, 2)
assert gate.sub_gate is cirq.Z
assert gate.num_controls() == 2
assert gate.control_values == ((1,), (1,))
assert gate.control_qid_shape == (2, 2)
assert gate.num_qubits() == 3
assert cirq.qid_shape(gate) == (2, 2, 2)
gate = cirq.ControlledGate(
cirq.ControlledGate(cirq.ControlledGate(cirq.Z, 3), num_controls=2), 2
)
assert gate.sub_gate is cirq.Z
assert gate.num_controls() == 7
assert gate.control_values == ((1,),) * 7
assert gate.control_qid_shape == (2,) * 7
assert gate.num_qubits() == 8
assert cirq.qid_shape(gate) == (2,) * 8
op = gate(*cirq.LineQubit.range(8))
assert op.qubits == (
cirq.LineQubit(0),
cirq.LineQubit(1),
cirq.LineQubit(2),
cirq.LineQubit(3),
cirq.LineQubit(4),
cirq.LineQubit(5),
cirq.LineQubit(6),
cirq.LineQubit(7),
)
gate = cirq.ControlledGate(cirq.Z, control_values=(0, (0, 1)))
assert gate.sub_gate is cirq.Z
assert gate.num_controls() == 2
assert gate.control_values == ((0,), (0, 1))
assert gate.control_qid_shape == (2, 2)
assert gate.num_qubits() == 3
assert cirq.qid_shape(gate) == (2, 2, 2)
gate = cirq.ControlledGate(cirq.Z, control_qid_shape=(3, 3))
assert gate.sub_gate is cirq.Z
assert gate.num_controls() == 2
assert gate.control_values == ((1,), (1,))
assert gate.control_qid_shape == (3, 3)
assert gate.num_qubits() == 3
assert cirq.qid_shape(gate) == (3, 3, 2)
measurements = []
self.measurements = measurements
self.fallback_result = fallback_result
def _perform_measurement(self, qubits):
return self.measurements # coverage: ignore
def copy(self):
return DummyActOnArgs(self.fallback_result,
self.measurements.copy()) # coverage: ignore
def _act_on_fallback_(self, action, qubits, allow_decompose):
return self.fallback_result
op = cirq.X(cirq.LineQubit(0))
def test_act_on_fallback_succeeds():
args = DummyActOnArgs(fallback_result=True)
cirq.act_on(op, args)
def test_act_on_fallback_fails():
args = DummyActOnArgs(fallback_result=NotImplemented)
with pytest.raises(TypeError, match='Failed to act'):
cirq.act_on(op, args)
def test_act_on_fallback_errors():
args = DummyActOnArgs(fallback_result=False)
def test_to_cirq_qubit() -> None:
assert cq.GridQubit(2, 3) == to_cirq_qubit((2, 3))
assert cq.NamedQubit("A Name") == to_cirq_qubit("A Name")
assert cq.LineQubit(101) == to_cirq_qubit(101)
def strip_ws(string):
return "".join(string.split())
def test_circuit_init_type():
qubits = [cirq.GridQubit(x, y) for x in range(2) for y in range(2)]
moment = cirq.Moment(cirq.H(qubits[0]))
circuit = cirq.Circuit(moment)
circuit3d = cirq_web.Circuit3D(circuit)
assert isinstance(circuit3d, cirq_web.Circuit3D)
@pytest.mark.parametrize('qubit', [cirq.GridQubit(0, 0), cirq.LineQubit(0)])
def test_circuit_client_code(qubit):
moment = cirq.Moment(cirq.H(qubit))
circuit = cirq_web.Circuit3D(cirq.Circuit(moment))
circuit_obj = [{
'wire_symbols': ['H'],
'location_info': [{
'row': 0,
'col': 0
}],
'color_info': ['yellow'],
'moment': 0,
}]
moments = 1
def test_cirq_to_circuit() -> None:
q0 = cq.LineQubit(0)
q1 = cq.LineQubit(1)
q2 = cq.LineQubit(2)
gate = cirq_to_circuit(cq.Circuit(cq.X(q0)))[0]
assert isinstance(gate, qf.X)
assert gate.qubits == (0, )
gate = cirq_to_circuit(cq.Circuit(cq.X(q1)**0.4))[0]
assert isinstance(gate, qf.XPow)
assert gate.qubits == (1, )
gate = cirq_to_circuit(cq.Circuit(cq.CZ(q1, q0)))[0]
assert isinstance(gate, qf.CZ)
assert gate.qubits == (1, 0)
gate = cirq_to_circuit(cq.Circuit(cq.CZ(q1, q0)**0.3))[0]
assert isinstance(gate, qf.CZPow)
assert gate.qubits == (1, 0)
assert gate.param("t") == 0.3
gate = cirq_to_circuit(cq.Circuit(cq.CNOT(q0, q1)))[0]
assert isinstance(gate, qf.CNot)
assert gate.qubits == (0, 1)
gate = cirq_to_circuit(cq.Circuit(cq.CNOT(q0, q1)**0.25))[0]
assert isinstance(gate, qf.CNotPow)
assert gate.qubits == (0, 1)
assert gate.param("t") == 0.25
gate = cirq_to_circuit(cq.Circuit(cq.SWAP(q0, q1)))[0]
assert isinstance(gate, qf.Swap)
gate = cirq_to_circuit(cq.Circuit(cq.ISWAP(q0, q1)))[0]
assert isinstance(gate, qf.ISwap)
gate = cirq_to_circuit(cq.Circuit(cq.CSWAP(q0, q1, q2)))[0]
assert isinstance(gate, qf.CSwap)
gate = cirq_to_circuit(cq.Circuit(cq.CCX(q0, q1, q2)))[0]
assert isinstance(gate, qf.CCNot)
gate = cirq_to_circuit(cq.Circuit(cq.CCZ(q0, q1, q2)))[0]
assert isinstance(gate, qf.CCZ)
gate = cirq_to_circuit(cq.Circuit(cq.I(q0)))[0]
assert isinstance(gate, qf.I)
gate = cirq_to_circuit(cq.Circuit(cq.XX(q0, q2)))[0]
assert isinstance(gate, qf.XX)
assert gate.param("t") == 1.0
gate = cirq_to_circuit(cq.Circuit(cq.XX(q0, q2)**0.3))[0]
assert isinstance(gate, qf.XX)
assert gate.param("t") == 0.3
gate = cirq_to_circuit(cq.Circuit(cq.YY(q0, q2)))[0]
assert isinstance(gate, qf.YY)
assert gate.param("t") == 1.0
gate = cirq_to_circuit(cq.Circuit(cq.YY(q0, q2)**0.3))[0]
assert isinstance(gate, qf.YY)
assert gate.param("t") == 0.3
gate = cirq_to_circuit(cq.Circuit(cq.ZZ(q0, q2)))[0]
assert isinstance(gate, qf.ZZ)
assert gate.param("t") == 1.0
gate = cirq_to_circuit(cq.Circuit(cq.ZZ(q0, q2)**0.3))[0]
assert isinstance(gate, qf.ZZ)
assert gate.param("t") == 0.3
# Check that cirq's parity gates are the same as QF's XX, YY, ZZ
# up to parity
U = (cq.XX(q0, q2)**0.8)._unitary_()
gate0 = qf.Unitary(U, [0, 1])
assert qf.gates_close(gate0, qf.XX(0.8, 0, 1))
U = (cq.YY(q0, q2)**0.3)._unitary_()
gate0 = qf.Unitary(U, [0, 1])
assert qf.gates_close(gate0, qf.YY(0.3, 0, 1))
U = (cq.ZZ(q0, q2)**0.2)._unitary_()
gate0 = qf.Unitary(U, [0, 1])
assert qf.gates_close(gate0, qf.ZZ(0.2, 0, 1))
):
convert_to_mitiq(item)
@pytest.mark.parametrize("to_type", SUPPORTED_PROGRAM_TYPES.keys())
def test_from_mitiq(to_type):
converted_circuit = convert_from_mitiq(cirq_circuit, to_type)
circuit, input_type = convert_to_mitiq(converted_circuit)
assert _equal(circuit, cirq_circuit)
assert input_type == to_type
@pytest.mark.parametrize(
"circuit_and_expected",
[
(cirq.Circuit(cirq.I.on(cirq.LineQubit(0))), np.array([1, 0])),
(cirq_circuit, np.array([1, 0, 0, 1]) / np.sqrt(2)),
],
)
@pytest.mark.parametrize("to_type", SUPPORTED_PROGRAM_TYPES.keys())
def test_accept_any_qprogram_as_input(circuit_and_expected, to_type):
circuit, expected = circuit_and_expected
wavefunction = get_wavefunction(convert_from_mitiq(circuit, to_type))
assert np.allclose(wavefunction, expected)
@pytest.mark.parametrize(
"circuit_and_type",
(
(qiskit_circuit, "qiskit"),
(pyquil_circuit, "pyquil"),
def test_serialize_noise_channel_unsupported_value(self):
"""Ensure serializing invalid channels fails gracefully."""
qubit = cirq.LineQubit(5)
simple_circuit = cirq.Circuit(cirq.depolarize(0.3)(qubit))
with self.assertRaises(ValueError):
serializer.serialize_circuit(simple_circuit)
def main():
# set up initial circuit
params = [1.2, 2.9, 0.1]
symbols = [sympy.Symbol(f"x{i}") for i in range(1,4)]
q = cirq.LineQubit(0)
circuit = cirq.Circuit.from_ops(
cirq.Rx(np.pi/4)(q), cirq.Ry(symbols[0])(q),
cirq.Rx(symbols[1])(q), cirq.Rz(symbols[2])(q))
# initialize the current state and target state
current_state = None
truth = np.array([0.149 + 0.238j, -0.745 - 0.607j])
truth = truth / np.linalg.norm(truth)
current_loss = 1
# Bloch sphere and color palette
rdbu = cm.get_cmap('bwr', 100)
b = qutip.Bloch()
b.sphere_color = "#ffffff"
b.point_color = [1]
b.xlabel = [r'$|$+$x\rangle$','']
b.ylabel = [r'$|$+$y\rangle$','']
b.show() # HACK - cycle through a showing to generate `axes` member
# cache points and their color
points_cache = []
colors_cache = []
# main routine:
system('clear')
print("Welcome. Prepare to optimize a PQC.")
print("\tRed colors mean you're approaching the optimum")
print("\tBlue colors mean you're moving away from the optimum")
for k in range(3000):
# 0) reset Bloch sphere and stage plotting of points cache
# Plot current state as black, previous ones according to heatmap
b.clear()
b.vector_color = ["#000000"] + colors_cache
# 1) Get user input for parameters
print("Iteration {}".format(k + 1))
print("Pick the parameters to try this iteration:")
params = []
i = 1
while len(params) < 4:
try:
params.append(float(input("Enter value for x{}: ".format(i))))
i += 1
except ValueError:
print("Invalid input. Enter parameters again")
params = []
i = 1
continue
except KeyboardInterrupt:
sys.exit()
# be sneaky and make one parameter do nothing
params = params[:2] + [params[3]]
# 2) Simulate the new state
current_state = cirq.Simulator().simulate(
circuit, param_resolver=dict(zip(symbols, params))).final_state
# color the vector and new point based on how well we guessed
current_loss = cost_function(current_state, truth)
current_vec = state_array_to_qobj(current_state)
b.add_states(current_vec)
b.add_states(points_cache)
print("Current loss: {} \n".format(current_loss))
# qutip's garbage mpl interface prevents fig management with gca()
b.show()
# 3) stage points cache for _next_ iteration
points_cache.append(current_vec)
colors_cache.append(colors.to_hex(rdbu(current_loss), keep_alpha=False))
def test_step_sample_measurement_ops_not_measurement():
q0 = cirq.LineQubit(0)
step_result = FakeStepResult([q0])
with pytest.raises(ValueError, match='MeasurementGate'):
step_result.sample_measurement_ops([cirq.X(q0)])
def _decompose_(self):
yield cirq.X(cirq.LineQubit(0))
yield cirq.Y(cirq.LineQubit(1))
def test_condition_flattening():
q0 = cirq.LineQubit(0)
op = cirq.X(q0).with_classical_controls('a').with_classical_controls('b')
assert set(map(str, op.classical_controls)) == {'a', 'b'}
assert isinstance(op._sub_operation, cirq.GateOperation)
def test_iter_definitions():
final_step_result = mock.Mock(cirq.StepResult)
final_step_result._simulator_state.return_value = []
dummy_trial_result = SimulationTrialResult(
params={}, measurements={}, final_step_result=final_step_result)
class FakeNonIterSimulatorImpl(
SimulatesAmplitudes,
SimulatesExpectationValues,
SimulatesFinalState,
):
"""A class which defines the non-Iterator simulator API methods.
After v0.12, simulators are expected to implement the *_iter methods.
"""
def compute_amplitudes_sweep(
self,
program: 'cirq.AbstractCircuit',
bitstrings: Sequence[int],
params: study.Sweepable,
qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
) -> Sequence[Sequence[complex]]:
return [[1.0]]
def simulate_expectation_values_sweep(
self,
program: 'cirq.AbstractCircuit',
observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
params: 'study.Sweepable',
qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
initial_state: Any = None,
permit_terminal_measurements: bool = False,
) -> List[List[float]]:
return [[1.0]]
def simulate_sweep(
self,
program: 'cirq.AbstractCircuit',
params: study.Sweepable,
qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
initial_state: Any = None,
) -> List[SimulationTrialResult]:
return [dummy_trial_result]
non_iter_sim = FakeNonIterSimulatorImpl()
q0 = cirq.LineQubit(0)
circuit = cirq.Circuit(cirq.X(q0))
bitstrings = [0b0]
params = {}
assert non_iter_sim.compute_amplitudes_sweep(circuit, bitstrings,
params) == [[1.0]]
amp_iter = non_iter_sim.compute_amplitudes_sweep_iter(
circuit, bitstrings, params)
assert next(amp_iter) == [1.0]
obs = cirq.X(q0)
assert non_iter_sim.simulate_expectation_values_sweep(
circuit, obs, params) == [[1.0]]
ev_iter = non_iter_sim.simulate_expectation_values_sweep_iter(
circuit, obs, params)
assert next(ev_iter) == [1.0]
assert non_iter_sim.simulate_sweep(circuit, params) == [dummy_trial_result]
state_iter = non_iter_sim.simulate_sweep_iter(circuit, params)
assert next(state_iter) == dummy_trial_result
def test_no_measurement_gates():
q0 = cirq.LineQubit(0)
with pytest.raises(ValueError, match='with measurements'):
_ = cirq.measure(q0).with_classical_controls('a')
(cirq.Z(q0) ** -0.5, cirq.CliffordGate.Z_nsqrt(q0)),
(cirq.X(q0) ** 0.25,
PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.Pauli.X)) ** 0.25),
(cirq.Y(q0) ** 0.25,
PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.Pauli.Y)) ** 0.25),
(cirq.Z(q0) ** 0.25,
PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.Pauli.Z)) ** 0.25),
(cirq.X(q0) ** 0, ()),
(cirq.CZ(q0, q1), cirq.CZ(q0, q1)),
(cirq.MeasurementGate('key')(q0, q1),
cirq.MeasurementGate('key')(q0, q1)),
))(cirq.LineQubit(0), cirq.LineQubit(1)))
def test_converts_various_ops(op, expected_ops):
before = cirq.Circuit.from_ops(op)
expected = cirq.Circuit.from_ops(expected_ops,
strategy=cirq.InsertStrategy.EARLIEST)
after = converted_gate_set(before)
assert after == expected
cirq.testing.assert_allclose_up_to_global_phase(
before.to_unitary_matrix(),
after.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
atol=1e-7)
cirq.testing.assert_allclose_up_to_global_phase(
after.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
expected.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
atol=1e-7)
def test_sympy_scope():
q = cirq.LineQubit(0)
a, b, c, d = sympy.symbols('a b c d')
inner = cirq.Circuit(
cirq.measure(q, key='a'),
cirq.X(q).with_classical_controls(a & b).with_classical_controls(c
| d),
)
middle = cirq.Circuit(
cirq.measure(q, key='b'),
cirq.measure(q, key=cirq.MeasurementKey('c', ('0', ))),
cirq.CircuitOperation(inner.freeze(), repetitions=2),
)
outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
circuit = outer_subcircuit.mapped_circuit(deep=True)
internal_controls = [
str(k) for op in circuit.all_operations()
for k in cirq.control_keys(op)
]
assert set(internal_controls) == {
'0:0:a', '0:1:a', '1:0:a', '1:1:a', '0:b', '1:b', 'c', 'd'
}
assert cirq.control_keys(outer_subcircuit) == {'c', 'd'}
assert cirq.control_keys(circuit) == {'c', 'd'}
assert circuit == cirq.Circuit(cirq.decompose(outer_subcircuit))
cirq.testing.assert_has_diagram(
cirq.Circuit(outer_subcircuit),
"""
[ [ 0: ───M───X(conditions=[c | d, a & b])─── ] ]
[ [ ║ ║ ] ]
[ [ a: ═══@═══^══════════════════════════════ ] ]
[ [ ║ ] ]
[ 0: ───M───M('0:c')───[ b: ═══════^══════════════════════════════ ]──────────── ]
[ ║ [ ║ ] ]
[ ║ [ c: ═══════^══════════════════════════════ ] ]
0: ───[ ║ [ ║ ] ]────────────
[ ║ [ d: ═══════^══════════════════════════════ ](loops=2) ]
[ ║ ║ ]
[ b: ═══@══════════════╬════════════════════════════════════════════════════════ ]
[ ║ ]
[ c: ══════════════════╬════════════════════════════════════════════════════════ ]
[ ║ ]
[ d: ══════════════════╩════════════════════════════════════════════════════════ ](loops=2)
║
c: ═══╬═════════════════════════════════════════════════════════════════════════════════════════════
║
d: ═══╩═════════════════════════════════════════════════════════════════════════════════════════════
""",
use_unicode_characters=True,
)
# pylint: disable=line-too-long
cirq.testing.assert_has_diagram(
circuit,
"""
0: ───────M───M('0:0:c')───M───X(conditions=[c | d, 0:0:a & 0:b])───M───X(conditions=[c | d, 0:1:a & 0:b])───M───M('1:0:c')───M───X(conditions=[c | d, 1:0:a & 1:b])───M───X(conditions=[c | d, 1:1:a & 1:b])───
║ ║ ║ ║ ║ ║ ║ ║ ║ ║
0:0:a: ═══╬════════════════@═══^════════════════════════════════════╬═══╬════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
║ ║ ║ ║ ║ ║ ║ ║ ║
0:1:a: ═══╬════════════════════╬════════════════════════════════════@═══^════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
║ ║ ║ ║ ║ ║ ║ ║
0:b: ═════@════════════════════^════════════════════════════════════════^════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
║ ║ ║ ║ ║ ║ ║
1:0:a: ════════════════════════╬════════════════════════════════════════╬════════════════════════════════════╬════════════════@═══^════════════════════════════════════╬═══╬════════════════════════════════════
║ ║ ║ ║ ║ ║
1:1:a: ════════════════════════╬════════════════════════════════════════╬════════════════════════════════════╬════════════════════╬════════════════════════════════════@═══^════════════════════════════════════
║ ║ ║ ║ ║
1:b: ══════════════════════════╬════════════════════════════════════════╬════════════════════════════════════@════════════════════^════════════════════════════════════════^════════════════════════════════════
║ ║ ║ ║
c: ════════════════════════════^════════════════════════════════════════^═════════════════════════════════════════════════════════^════════════════════════════════════════^════════════════════════════════════
║ ║ ║ ║
d: ════════════════════════════^════════════════════════════════════════^═════════════════════════════════════════════════════════^════════════════════════════════════════^════════════════════════════════════
""",
use_unicode_characters=True,
)
def test_from_cirq_qubit() -> None:
assert from_cirq_qubit(cq.GridQubit(2, 3)) == (2, 3)
assert from_cirq_qubit(cq.NamedQubit("A Name")) == "A Name"
assert from_cirq_qubit(cq.LineQubit(101)) == 101
def test_graph_device():
one_qubit_duration = cirq.Duration(picos=10)
two_qubit_duration = cirq.Duration(picos=1)
one_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(
one_qubit_duration)
two_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(
two_qubit_duration)
empty_device = ccgd.UndirectedGraphDevice()
assert not empty_device.qubits
assert not empty_device.edges
n_qubits = 4
qubits = cirq.LineQubit.range(n_qubits)
edges = {(cirq.LineQubit(i), cirq.LineQubit((i + 1) % n_qubits)):
two_qubit_edge
for i in range(n_qubits)}
edges.update({(cirq.LineQubit(i), ): one_qubit_edge
for i in range(n_qubits)})
device_graph = ccgd.UndirectedHypergraph(labelled_edges=edges)
def not_cnots(first_op, second_op):
if all(
isinstance(op, cirq.GateOperation) and op.gate == cirq.CNOT
for op in (first_op, second_op)):
raise ValueError('Simultaneous CNOTs')
assert ccgd.is_undirected_device_graph(device_graph)
with pytest.raises(TypeError):
ccgd.UndirectedGraphDevice('abc')
constraint_edges = {
(frozenset(cirq.LineQubit.range(2)),
frozenset(cirq.LineQubit.range(2, 4))):
None,
(frozenset(cirq.LineQubit.range(1, 3)),
frozenset((cirq.LineQubit(0), cirq.LineQubit(3)))):
not_cnots
}
crosstalk_graph = ccgd.UndirectedHypergraph(
labelled_edges=constraint_edges)
assert ccgd.is_crosstalk_graph(crosstalk_graph)
with pytest.raises(TypeError):
ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')
graph_device = ccgd.UndirectedGraphDevice(device_graph)
assert graph_device.crosstalk_graph == ccgd.UndirectedHypergraph()
graph_device = ccgd.UndirectedGraphDevice(device_graph,
crosstalk_graph=crosstalk_graph)
assert sorted(graph_device.edges) == sorted(device_graph.edges)
assert graph_device.qubits == tuple(qubits)
assert graph_device.device_graph == device_graph
assert graph_device.labelled_edges == device_graph.labelled_edges
assert graph_device.duration_of(cirq.X(qubits[2])) == one_qubit_duration
assert (graph_device.duration_of(
cirq.CNOT(*qubits[:2])) == two_qubit_duration)
with pytest.raises(KeyError):
graph_device.duration_of(cirq.CNOT(qubits[0], qubits[2]))
with pytest.raises(ValueError):
graph_device.validate_operation(cirq.CNOT(qubits[0], qubits[2]))
with pytest.raises(AttributeError):
graph_device.validate_operation(list((2, 3)))
moment = cirq.Moment([cirq.CNOT(*qubits[:2]), cirq.CNOT(*qubits[2:])])
with pytest.raises(ValueError):
graph_device.validate_moment(moment)
moment = cirq.Moment(
[cirq.CNOT(qubits[0], qubits[3]),
cirq.CZ(qubits[1], qubits[2])])
graph_device.validate_moment(moment)
moment = cirq.Moment(
[cirq.CNOT(qubits[0], qubits[3]),
cirq.CNOT(qubits[1], qubits[2])])
with pytest.raises(ValueError):
graph_device.validate_moment(moment)
def test_commutes():
assert cirq.commutes(cirq.ZPowGate(exponent=sympy.Symbol('t')), cirq.Z)
assert cirq.commutes(cirq.Z, cirq.Z(cirq.LineQubit(0)), default=None) is None
assert cirq.commutes(cirq.Z ** 0.1, cirq.XPowGate(exponent=0))
