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))