def matrix_to_sycamore_operations( target_qubits: List[cirq.GridQubit], matrix: np.ndarray) -> Tuple[cirq.OP_TREE, List[cirq.GridQubit]]: """A method to convert a unitary matrix to a list of Sycamore operations. This method will return a list of `cirq.Operation`s using the qubits and (optionally) ancilla qubits to implement the unitary matrix `matrix` on the target qubits `qubits`. The operations are also supported by `cirq.google.gate_sets.SYC_GATESET`. Args: target_qubits: list of qubits the returned operations will act on. The qubit order defined by the list is assumed to be used by the operations to implement `matrix`. matrix: a matrix that is guaranteed to be unitary and of size (2**len(qs), 2**len(qs)). Returns: A tuple of operations and ancilla qubits allocated. Operations: In case the matrix is supported, a list of operations `ops` is returned. `ops` acts on `qs` qubits and for which `cirq.unitary(ops)` is equal to `matrix` up to certain tolerance. In case the matrix is not supported, it might return NotImplemented to reduce the noise in the judge output. Ancilla qubits: In case ancilla qubits are allocated a list of ancilla qubits. Otherwise an empty list. . """ def optimize_circuit(circ): ouut = [] converter = cirq.google.ConvertToSycamoreGates() for _ in circ.all_operations(): ouut.append(converter.convert(_)) return cirq.google.optimized_for_sycamore( cirq.Circuit(ouut), optimizer_type="sycamore"), [] if np.trace(matrix) == len(matrix): return [], [] if len(matrix) == 2: try: comparison = matrix == cirq.unitary(cirq.Z) if (comparison.all()): return cirq.Z(target_qubits[0]), [] comparison = matrix == cirq.unitary(cirq.X) if (comparison.all()): return cirq.X(target_qubits[0]), [] comparison = matrix == cirq.unitary(cirq.Y) if (comparison.all()): return cirq.Y(target_qubits[0]), [] comparison = matrix == cirq.unitary(cirq.H) if (comparison.all()): return cirq.H.on(target_qubits[0]), [] comparison = matrix == cirq.unitary(cirq.S) if (comparison.all()): return cirq.S(target_qubits[0]), [] comparison = matrix == cirq.unitary(cirq.T) if (comparison.all()): return cirq.T(target_qubits[0]), [] except [TypeError, ValueError]: return NotImplemented, [] if len(matrix) == 4: try: comparison = matrix == cirq.unitary(cirq.CNOT) if (comparison.all()): return optimize_circuit( cirq.Circuit(cirq.CNOT(target_qubits[0], target_qubits[1]))) comparison = matrix == cirq.unitary(cirq.XX) if (comparison.all()): return optimize_circuit( cirq.Circuit(cirq.XX(target_qubits[0], target_qubits[1]))) comparison = matrix == cirq.unitary(cirq.YY) if (comparison.all()): return optimize_circuit( cirq.Circuit(cirq.YY(target_qubits[0], target_qubits[1]))) comparison = matrix == cirq.unitary(cirq.ZZ) if (comparison.all()): return optimize_circuit( cirq.Circuit(cirq.ZZ(target_qubits[0], target_qubits[1]))) comparison = matrix == cirq.unitary(cirq.google.SYC) if (comparison.all()): return optimize_circuit( cirq.Circuit( cirq.google.SYC(target_qubits[0], target_qubits[1]))) except TypeError: return NotImplemented, [] if len(matrix) == 8: try: comparison = matrix == cirq.unitary(cirq.CCX) if (comparison.all()): return optimize_circuit( cirq.Circuit( cirq.CCX(target_qubits[0], target_qubits[1], target_qubits[2]))) comparison = matrix == cirq.unitary(cirq.CSWAP) if (comparison.all()): return optimize_circuit( cirq.Circuit( cirq.CSWAP(target_qubits[0], target_qubits[1], target_qubits[2]))) comparison = matrix == cirq.unitary(cirq.CCZ) if (comparison.all()): return optimize_circuit( cirq.Circuit( cirq.CCZ(target_qubits[0], target_qubits[1], target_qubits[2]))) comparison = matrix == cirq.unitary( cirq.ControlledGate(cirq.ISWAP**0.5, 1)) if (comparison.all()): return cirq.ControlledGate(cirq.ISWAP**0.5, 1) except TypeError: return NotImplemented, [] if len(matrix) == 16: try: comparison = matrix == cirq.unitary( cirq.ControlledGate(cirq.ISWAP**0.5, 2)) if (comparison.all()): return optimize_circuit( cirq.Circuit( cirq.ControlledGate(sub_gate=cirq.ISWAP**0.5).on( target_qubits[2], target_qubits[0], target_qubits[1]))) except TypeError: return NotImplemented, [] return NotImplemented, []
# See the License for the specific language governing permissions and # limitations under the License. import pytest import cirq from cirq.contrib.paulistring import converted_gate_set @pytest.mark.parametrize( 'op,expected_ops', ( lambda q0, q1: ( (cirq.X(q0), cirq.SingleQubitCliffordGate.X(q0)), (cirq.Y(q0), cirq.SingleQubitCliffordGate.Y(q0)), (cirq.Z(q0), cirq.SingleQubitCliffordGate.Z(q0)), (cirq.X(q0) ** 0.5, cirq.SingleQubitCliffordGate.X_sqrt(q0)), (cirq.Y(q0) ** 0.5, cirq.SingleQubitCliffordGate.Y_sqrt(q0)), (cirq.Z(q0) ** 0.5, cirq.SingleQubitCliffordGate.Z_sqrt(q0)), (cirq.X(q0) ** -0.5, cirq.SingleQubitCliffordGate.X_nsqrt(q0)), (cirq.Y(q0) ** -0.5, cirq.SingleQubitCliffordGate.Y_nsqrt(q0)), (cirq.Z(q0) ** -0.5, cirq.SingleQubitCliffordGate.Z_nsqrt(q0)), (cirq.X(q0) ** 0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.X.on(q0)])) ** 0.25), (cirq.Y(q0) ** 0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.Y.on(q0)])) ** 0.25), (cirq.Z(q0) ** 0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.Z.on(q0)])) ** 0.25), (cirq.X(q0) ** 0, ()), (cirq.CZ(q0, q1), cirq.CZ(q0, q1)), (cirq.measure(q0, q1, key='key'), cirq.measure(q0, q1, key='key')), ) )(cirq.LineQubit(0), cirq.LineQubit(1)),
Q0 = cirq.GridQubit(2, 4) Q1 = cirq.GridQubit(2, 5) X_PROTO = op_proto({ 'xpowgate': { 'exponent': { 'float_value': 1.0 } }, 'qubit_constant_index': [0], }) OPERATIONS = [ (cirq.X(Q0), X_PROTO), ( cirq.Y(Q0), op_proto({ 'ypowgate': { 'exponent': { 'float_value': 1.0 } }, 'qubit_constant_index': [0], }), ), ( cirq.Z(Q0), op_proto({ 'zpowgate': { 'exponent': { 'float_value': 1.0
def test_readout_correction(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') ro_bsa, ro_settings, ro_meas_spec_setting = _get_mock_readout_calibration() # observables range from 1 to -1 while bitstrings range from 0 to 1 assert ro_bsa.mean(ro_settings[0]) == 0.8 assert ro_bsa.mean(ro_settings[1]) == 0.82 assert np.isclose(ro_bsa.mean(ro_meas_spec_setting), 0.8 * 0.82, atol=0.05) bitstrings = np.array( [ [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 1], [1, 1], ], dtype=np.uint8, ) chunksizes = np.asarray([len(bitstrings)]) timestamps = np.asarray([datetime.datetime.now()]) qubit_to_index = {a: 0, b: 1} settings = list( cw.observables_to_settings( [cirq.X(a) * cirq.Y(b), cirq.X(a), cirq.Y(b)], qubits=[a, b])) meas_spec = _MeasurementSpec(settings[0], {}) # First, make one with no readout correction bsa1 = cw.BitstringAccumulator( meas_spec=meas_spec, simul_settings=settings, qubit_to_index=qubit_to_index, bitstrings=bitstrings, chunksizes=chunksizes, timestamps=timestamps, ) # [XY: one excitation, X: one excitation, Y: two excitations] np.testing.assert_allclose([1 - 1 / 4, 1 - 1 / 4, 1 - 2 / 4], bsa1.means()) np.testing.assert_allclose([0.75, 0.75, 0.5], bsa1.means()) # Turn on readout correction bsa2 = cw.BitstringAccumulator( meas_spec=meas_spec, simul_settings=settings, qubit_to_index=qubit_to_index, bitstrings=bitstrings, chunksizes=chunksizes, timestamps=timestamps, readout_calibration=ro_bsa, ) # Readout correction increases variance for setting in settings: assert bsa2.variance(setting) > bsa1.variance(setting) np.testing.assert_allclose([0.75 / (0.8 * 0.82), 0.75 / 0.8, 0.5 / 0.82], bsa2.means(), atol=0.01) # Variance becomes singular when readout error is 50/50 ro_bsa_50_50, _, _ = _get_mock_readout_calibration(qa_0=50, qa_1=50) bsa3 = cw.BitstringAccumulator( meas_spec=meas_spec, simul_settings=settings, qubit_to_index=qubit_to_index, bitstrings=bitstrings, chunksizes=chunksizes, timestamps=timestamps, readout_calibration=ro_bsa_50_50, ) with pytest.raises(ZeroDivisionError): bsa3.means() assert bsa3.variance(settings[1]) == np.inf
def _get_circuit_proto_pairs(): q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(0, 1) pairs = [ # HPOW and aliases. (cirq.Circuit(cirq.HPowGate(exponent=0.3)(q0)), _build_op_proto("HP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.HPowGate(exponent=sympy.Symbol('alpha'))(q0)), _build_op_proto("HP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.HPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0)), _build_op_proto("HP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0'])), (cirq.Circuit(cirq.H(q0)), _build_op_proto("HP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0'])), # XPOW and aliases. (cirq.Circuit(cirq.XPowGate(exponent=0.3)(q0)), _build_op_proto("XP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.XPowGate(exponent=sympy.Symbol('alpha'))(q0)), _build_op_proto("XP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.XPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0)), _build_op_proto("XP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0'])), (cirq.Circuit(cirq.X(q0)), _build_op_proto("XP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0'])), # YPOW and aliases (cirq.Circuit(cirq.YPowGate(exponent=0.3)(q0)), _build_op_proto("YP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.YPowGate(exponent=sympy.Symbol('alpha'))(q0)), _build_op_proto("YP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.YPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0)), _build_op_proto("YP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0'])), (cirq.Circuit(cirq.Y(q0)), _build_op_proto("YP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0'])), # ZPOW and aliases. (cirq.Circuit(cirq.ZPowGate(exponent=0.3)(q0)), _build_op_proto("ZP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.ZPowGate(exponent=sympy.Symbol('alpha'))(q0)), _build_op_proto("ZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0'])), (cirq.Circuit(cirq.ZPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0)), _build_op_proto("ZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0'])), (cirq.Circuit(cirq.Z(q0)), _build_op_proto("ZP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0'])), # XXPow and aliases (cirq.Circuit(cirq.XXPowGate(exponent=0.3)(q0, q1)), _build_op_proto("XXP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.XXPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("XXP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.XXPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("XXP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.XX(q0, q1)), _build_op_proto("XXP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # YYPow and aliases (cirq.Circuit(cirq.YYPowGate(exponent=0.3)(q0, q1)), _build_op_proto("YYP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.YYPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("YYP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.YYPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("YYP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.YY(q0, q1)), _build_op_proto("YYP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # ZZPow and aliases (cirq.Circuit(cirq.ZZPowGate(exponent=0.3)(q0, q1)), _build_op_proto("ZZP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.ZZPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("ZZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.ZZPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("ZZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.ZZ(q0, q1)), _build_op_proto("ZZP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # CZPow and aliases (cirq.Circuit(cirq.CZPowGate(exponent=0.3)(q0, q1)), _build_op_proto("CZP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.CZPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("CZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.CZPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("CZP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.CZ(q0, q1)), _build_op_proto("CZP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # CNOTPow and aliases (cirq.Circuit(cirq.CNotPowGate(exponent=0.3)(q0, q1)), _build_op_proto("CNP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.CNotPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("CNP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.CNotPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("CNP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.CNOT(q0, q1)), _build_op_proto("CNP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # SWAPPow and aliases (cirq.Circuit(cirq.SwapPowGate(exponent=0.3)(q0, q1)), _build_op_proto("SP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.SwapPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("SP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.SwapPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("SP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.SWAP(q0, q1)), _build_op_proto("SP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # ISWAPPow and aliases (cirq.Circuit(cirq.ISwapPowGate(exponent=0.3)(q0, q1)), _build_op_proto("ISP", ['exponent', 'exponent_scalar', 'global_shift'], [0.3, 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.ISwapPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("ISP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 1.0, 0.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.ISwapPowGate(exponent=3.1 * sympy.Symbol('alpha'))(q0, q1)), _build_op_proto("ISP", ['exponent', 'exponent_scalar', 'global_shift'], ['alpha', 3.1, 0.0], ['0_0', '0_1'])), (cirq.Circuit(cirq.ISWAP(q0, q1)), _build_op_proto("ISP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, 0.0], ['0_0', '0_1'])), # PhasedXPow and aliases (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=0.9, exponent=0.3, global_shift=0.2)(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], [0.9, 1.0, 0.3, 1.0, 0.2], ['0_0'])), (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=sympy.Symbol('alpha'), exponent=0.3)(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], ['alpha', 1.0, 0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=3.1 * sympy.Symbol('alpha'), exponent=0.3)(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], ['alpha', 3.1, 0.3, 1.0, 0.0], ['0_0'])), (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=0.9, exponent=sympy.Symbol('beta'))(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], [0.9, 1.0, 'beta', 1.0, 0.0], ['0_0'])), (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=0.9, exponent=5.1 * sympy.Symbol('beta'))(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], [0.9, 1.0, 'beta', 5.1, 0.0], ['0_0'])), (cirq.Circuit( cirq.PhasedXPowGate(phase_exponent=3.1 * sympy.Symbol('alpha'), exponent=5.1 * sympy.Symbol('beta'))(q0)), _build_op_proto("PXP", [ 'phase_exponent', 'phase_exponent_scalar', 'exponent', 'exponent_scalar', 'global_shift' ], ['alpha', 3.1, 'beta', 5.1, 0.0], ['0_0'])), # RX, RY, RZ with symbolization is tested in special cases as the # string comparison of the float converted sympy.pi does not happen # smoothly. See: test_serialize_deserialize_special_case_one_qubit (cirq.Circuit(cirq.rx(np.pi)(q0)), _build_op_proto("XP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, -0.5], ['0_0'])), (cirq.Circuit(cirq.ry(np.pi)(q0)), _build_op_proto("YP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, -0.5], ['0_0'])), (cirq.Circuit(cirq.rz(np.pi)(q0)), _build_op_proto("ZP", ['exponent', 'exponent_scalar', 'global_shift'], [1.0, 1.0, -0.5], ['0_0'])), # Identity (cirq.Circuit(cirq.I(q0)), _build_op_proto("I", ['unused'], [True], ['0_0'])), # FSimGate (cirq.Circuit(cirq.FSimGate(theta=0.1, phi=0.2)(q0, q1)), _build_op_proto("FSIM", ['theta', 'theta_scalar', 'phi', 'phi_scalar'], [0.1, 1.0, 0.2, 1.0], ['0_0', '0_1'])), (cirq.Circuit( cirq.FSimGate(theta=2.1 * sympy.Symbol("alpha"), phi=1.3 * sympy.Symbol("beta"))(q0, q1)), _build_op_proto("FSIM", ['theta', 'theta_scalar', 'phi', 'phi_scalar'], ['alpha', 2.1, 'beta', 1.3], ['0_0', '0_1'])), ] return pairs
def generator(depth): if depth <= 0: yield cirq.CZ(q0, q1), cirq.Y(q0) else: yield cirq.X(q0), generator(depth - 1) yield cirq.Z(q0)
def test_pauli_sum_repr(): q = cirq.LineQubit.range(2) pstr1 = cirq.X(q[0]) * cirq.X(q[1]) pstr2 = cirq.Y(q[0]) * cirq.Y(q[1]) psum = pstr1 + 2 * pstr2 + 1 cirq.testing.assert_equivalent_repr(psum)
def test_ignore_non_composite(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit() circuit.append([cirq.X(q0), cirq.Y(q1), cirq.CZ(q0, q1), cirq.Z(q0)]) assert_optimizes(None, circuit.copy(), circuit)
import tensorflow_quantum as tfq import cirq import sympy import numpy as np #%matplotlib inline import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt from cirq.contrib.svg import SVGCircuit qubit = cirq.GridQubit(0, 0) my_circuit = cirq.Circuit(cirq.Y(qubit)**sympy.Symbol('alpha')) SVGCircuit(my_circuit) pauli_x = cirq.X(qubit) pauli_x def my_expectation(op, alpha): """Compute ⟨Y(alpha)| `op` | Y(alpha)⟩""" params = {'alpha': alpha} sim = cirq.Simulator() final_state_vector = sim.simulate(my_circuit, params).final_state_vector return op.expectation_from_state_vector(final_state_vector, { qubit: 0 }).real
def test_scaled_unitary_consistency(): a, b = cirq.LineQubit.range(2) cirq.testing.assert_implements_consistent_protocols(2 * cirq.X(a) * cirq.Y(b)) cirq.testing.assert_implements_consistent_protocols(1j * cirq.X(a) * cirq.Y(b))
def test_circuit_0(): qusetta_circuit = [ "H(0)", "H(1)", "CX(0, 1)", "CX(1, 0)", "CZ(2, 0)", "I(1)", "SWAP(0, 3)", "RY(PI)(1)", "X(2)", "S(0)", "Z(2)", "Y(3)", "RX(0.4*PI)(0)", "T(2)", "RZ(-0.3*PI)(2)", "CCX(0, 1, 2)" ] cirq_circuit = cirq.Circuit() q = [cirq.LineQubit(i) for i in range(4)] cirq_circuit.append(cirq.H(q[0])) cirq_circuit.append(cirq.H(q[1])) cirq_circuit.append(cirq.CX(q[0], q[1])) cirq_circuit.append(cirq.CX(q[1], q[0])) cirq_circuit.append(cirq.CZ(q[2], q[0])) cirq_circuit.append(cirq.I(q[1])) cirq_circuit.append(cirq.SWAP(q[0], q[3])) cirq_circuit.append(cirq.ry(pi)(q[1])) cirq_circuit.append(cirq.X(q[2])) cirq_circuit.append(cirq.S(q[0])) cirq_circuit.append(cirq.Z(q[2])) cirq_circuit.append(cirq.Y(q[3])) cirq_circuit.append(cirq.rx(.4 * pi)(q[0])) cirq_circuit.append(cirq.T(q[2])) cirq_circuit.append(cirq.rz(-.3 * pi)(q[2])) cirq_circuit.append(cirq.CCX(q[0], q[1], q[2])) # ibm is weird so we flip all of the qubits here qiskit_circuit = qiskit.QuantumCircuit(4) qiskit_circuit.h(3 - 0) qiskit_circuit.h(3 - 1) qiskit_circuit.cx(3 - 0, 3 - 1) qiskit_circuit.cx(3 - 1, 3 - 0) qiskit_circuit.cz(3 - 2, 3 - 0) qiskit_circuit.i(3 - 1) qiskit_circuit.swap(3 - 0, 3 - 3) qiskit_circuit.ry(pi, 3 - 1) qiskit_circuit.x(3 - 2) qiskit_circuit.s(3 - 0) qiskit_circuit.z(3 - 2) qiskit_circuit.y(3 - 3) qiskit_circuit.rx(.4 * pi, 3 - 0) qiskit_circuit.t(3 - 2) qiskit_circuit.rz(-.3 * pi, 3 - 2) qiskit_circuit.ccx(3 - 0, 3 - 1, 3 - 2) quasar_circuit = quasar.Circuit() quasar_circuit.H(0) quasar_circuit.H(1) quasar_circuit.CX(0, 1) quasar_circuit.CX(1, 0) quasar_circuit.CZ(2, 0) quasar_circuit.I(1) quasar_circuit.SWAP(0, 3) quasar_circuit.Ry(1, pi) quasar_circuit.X(2) quasar_circuit.S(0) quasar_circuit.Z(2) quasar_circuit.Y(3) quasar_circuit.Rx(0, .2 * pi) quasar_circuit.T(2) quasar_circuit.Rz(2, -.15 * pi) quasar_circuit.CCX(0, 1, 2) # tests all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
def test_get_gradient_circuits(self): """Test that the correct objects are returned.""" # Minimal linear combination. input_weights = [1.0, -0.5] input_perturbations = [1.0, -1.5] diff = linear_combination.LinearCombination(input_weights, input_perturbations) # Circuits to differentiate. symbols = [sympy.Symbol("s0"), sympy.Symbol("s1")] q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(1, 2) input_programs = util.convert_to_tensor([ cirq.Circuit(cirq.X(q0)**symbols[0], cirq.ry(symbols[1])(q1)), cirq.Circuit(cirq.rx(symbols[0])(q0), cirq.Y(q1)**symbols[1]), ]) input_symbol_names = tf.constant([str(s) for s in symbols]) input_symbol_values = tf.constant([[1.5, -2.7], [-0.3, 0.9]]) # For each program in the input batch: LinearCombination creates a copy # of that program for each symbol in the batch; then for each symbol, # the program is copied for each non-zero perturbation; finally, a # single copy is added for the zero perturbation (no zero pert here). expected_batch_programs = tf.stack([[input_programs[0]] * 4, [input_programs[1]] * 4]) expected_new_symbol_names = input_symbol_names # For each program in the input batch: first, the input symbol_values # for the program are tiled to the number of copies in the output. tiled_symbol_values = tf.stack([[input_symbol_values[0]] * 4, [input_symbol_values[1]] * 4]) # Then we create the tensor of perturbations to apply to these symbol # values: for each symbol we tile out the non-zero perturbations at that # symbol's index, keeping all the other symbol perturbations at zero. # Perturbations are the same for each program. single_program_perturbations = tf.stack([[input_perturbations[0], 0.0], [input_perturbations[1], 0.0], [0.0, input_perturbations[0]], [0.0, input_perturbations[1]]]) tiled_perturbations = tf.stack( [single_program_perturbations, single_program_perturbations]) # Finally we add the perturbations to the original symbol values. expected_batch_symbol_values = tiled_symbol_values + tiled_perturbations # The map for LinearCombination is the same for every program. individual_batch_mapper = tf.stack( [[input_weights[0], input_weights[1], 0.0, 0.0], [0.0, 0.0, input_weights[0], input_weights[1]]]) expected_batch_mapper = tf.stack( [individual_batch_mapper, individual_batch_mapper]) (test_batch_programs, test_new_symbol_names, test_batch_symbol_values, test_batch_mapper) = diff.get_gradient_circuits( input_programs, input_symbol_names, input_symbol_values) self.assertAllEqual(expected_batch_programs, test_batch_programs) self.assertAllEqual(expected_new_symbol_names, test_new_symbol_names) self.assertAllClose(expected_batch_symbol_values, test_batch_symbol_values, atol=1e-6) self.assertAllClose(expected_batch_mapper, test_batch_mapper, atol=1e-6)
def test_fixed_single_qubit_rotations(): a, b, c, d = cirq.LineQubit.range(4) assert_url_to_circuit_returns( '{"cols":[["H","X","Y","Z"]]}', cirq.Circuit(cirq.H(a), cirq.X(b), cirq.Y(c), cirq.Z(d)) ) assert_url_to_circuit_returns( '{"cols":[["X^½","X^⅓","X^¼"],' '["X^⅛","X^⅟₁₆","X^⅟₃₂"],' '["X^-½","X^-⅓","X^-¼"],' '["X^-⅛","X^-⅟₁₆","X^-⅟₃₂"]]}', cirq.Circuit( cirq.X(a) ** (1 / 2), cirq.X(b) ** (1 / 3), cirq.X(c) ** (1 / 4), cirq.X(a) ** (1 / 8), cirq.X(b) ** (1 / 16), cirq.X(c) ** (1 / 32), cirq.X(a) ** (-1 / 2), cirq.X(b) ** (-1 / 3), cirq.X(c) ** (-1 / 4), cirq.X(a) ** (-1 / 8), cirq.X(b) ** (-1 / 16), cirq.X(c) ** (-1 / 32), ), ) assert_url_to_circuit_returns( '{"cols":[["Y^½","Y^⅓","Y^¼"],' '["Y^⅛","Y^⅟₁₆","Y^⅟₃₂"],' '["Y^-½","Y^-⅓","Y^-¼"],' '["Y^-⅛","Y^-⅟₁₆","Y^-⅟₃₂"]]}', cirq.Circuit( cirq.Y(a) ** (1 / 2), cirq.Y(b) ** (1 / 3), cirq.Y(c) ** (1 / 4), cirq.Y(a) ** (1 / 8), cirq.Y(b) ** (1 / 16), cirq.Y(c) ** (1 / 32), cirq.Y(a) ** (-1 / 2), cirq.Y(b) ** (-1 / 3), cirq.Y(c) ** (-1 / 4), cirq.Y(a) ** (-1 / 8), cirq.Y(b) ** (-1 / 16), cirq.Y(c) ** (-1 / 32), ), ) assert_url_to_circuit_returns( '{"cols":[["Z^½","Z^⅓","Z^¼"],' '["Z^⅛","Z^⅟₁₆","Z^⅟₃₂"],' '["Z^⅟₆₄","Z^⅟₁₂₈"],' '["Z^-½","Z^-⅓","Z^-¼"],' '["Z^-⅛","Z^-⅟₁₆"]]}', cirq.Circuit( cirq.Z(a) ** (1 / 2), cirq.Z(b) ** (1 / 3), cirq.Z(c) ** (1 / 4), cirq.Z(a) ** (1 / 8), cirq.Z(b) ** (1 / 16), cirq.Z(c) ** (1 / 32), cirq.Z(a) ** (1 / 64), cirq.Z(b) ** (1 / 128), cirq.Moment([cirq.Z(a) ** (-1 / 2), cirq.Z(b) ** (-1 / 3), cirq.Z(c) ** (-1 / 4)]), cirq.Z(a) ** (-1 / 8), cirq.Z(b) ** (-1 / 16), ), )
def test_get_gradient_circuits(self): """Test that the correct objects are returned.""" diff = parameter_shift.ParameterShift() # Circuits to differentiate. symbols = [sympy.Symbol("s0"), sympy.Symbol("s1")] q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(1, 2) input_programs = util.convert_to_tensor([ cirq.Circuit( cirq.X(q0)**symbols[0], cirq.Y(q0)**symbols[0], cirq.ry(symbols[1])(q1)), cirq.Circuit(cirq.Y(q1)**symbols[1]), ]) input_symbol_names = tf.constant([str(s) for s in symbols]) input_symbol_values = tf.constant([[1.5, -2.7], [-0.3, 0.9]]) # First, for each symbol `s`, check how many times `s` appears in each # program `p`, `n_ps`. Let `n_param_gates` be the maximum of `n_ps` over # all symbols and programs. Then, the shape of `batch_programs` will be # [n_programs, n_symbols * n_param_gates * n_shifts], where `n_shifts` # is 2 because we decompose into gates with 2 eigenvalues. For row index # `p` we have for column indices between `i * n_param_gates * n_shifts` # and `(i + 1) * n_param_gates * n_shifts`, the first `n_pi * 2` # programs are parameter shifted versions of `input_programs[p]` and the # remaining programs are empty. # Here, `n_param_gates` is 2. impurity_symbol_name = "_impurity_for_param_shift" impurity_symbol = sympy.Symbol(impurity_symbol_name) expected_batch_programs_0 = util.convert_to_tensor([ cirq.Circuit( cirq.X(q0)**impurity_symbol, cirq.Y(q0)**symbols[0], cirq.ry(symbols[1])(q1)), cirq.Circuit( cirq.X(q0)**impurity_symbol, cirq.Y(q0)**symbols[0], cirq.ry(symbols[1])(q1)), cirq.Circuit( cirq.X(q0)**symbols[0], cirq.Y(q0)**impurity_symbol, cirq.ry(symbols[1])(q1)), cirq.Circuit( cirq.X(q0)**symbols[0], cirq.Y(q0)**impurity_symbol, cirq.ry(symbols[1])(q1)), cirq.Circuit( cirq.X(q0)**symbols[0], cirq.Y(q0)**symbols[0], cirq.ry(impurity_symbol)(q1)), cirq.Circuit( cirq.X(q0)**symbols[0], cirq.Y(q0)**symbols[0], cirq.ry(impurity_symbol)(q1)), cirq.Circuit(), cirq.Circuit() ]) expected_batch_programs_1 = util.convert_to_tensor([ cirq.Circuit(), cirq.Circuit(), cirq.Circuit(), cirq.Circuit(), cirq.Circuit(cirq.Y(q1)**impurity_symbol), cirq.Circuit(cirq.Y(q1)**impurity_symbol), cirq.Circuit(), cirq.Circuit() ]) expected_batch_programs = tf.stack( [expected_batch_programs_0, expected_batch_programs_1]) # The new symbols are the old ones, with an extra used for shifting. expected_new_symbol_names = tf.concat( [input_symbol_names, tf.constant([impurity_symbol_name])], 0) # The batch symbol values are the input symbol values, tiled and with # shifted values appended. Locations that have empty programs should # also have zero for the shift. # The shifted values are the original value plus 1/2 divided by the # `exponent_scalar` of the gate. expected_batch_symbol_values = tf.constant( [[[1.5, -2.7, 1.5 + 0.5], [1.5, -2.7, 1.5 - 0.5], [1.5, -2.7, 1.5 + 0.5], [1.5, -2.7, 1.5 - 0.5], [1.5, -2.7, -2.7 + np.pi / 2], [1.5, -2.7, -2.7 - np.pi / 2], [1.5, -2.7, -2.7], [1.5, -2.7, -2.7]], [[-0.3, 0.9, -0.3], [-0.3, 0.9, -0.3], [-0.3, 0.9, -0.3], [-0.3, 0.9, -0.3], [-0.3, 0.9, 0.9 + 0.5], [-0.3, 0.9, 0.9 - 0.5], [-0.3, 0.9, 0.9], [-0.3, 0.9, 0.9]]]) # Empty program locations are given zero weight. expected_batch_weights = tf.constant( [[[np.pi / 2, -np.pi / 2, np.pi / 2, -np.pi / 2], [0.5, -0.5, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [np.pi / 2, -np.pi / 2, 0.0, 0.0]]]) expected_batch_mapper = tf.constant([[[0, 1, 2, 3], [4, 5, 6, 7]], [[0, 1, 2, 3], [4, 5, 6, 7]]]) (test_batch_programs, test_new_symbol_names, test_batch_symbol_values, test_batch_weights, test_batch_mapper) = diff.get_gradient_circuits( input_programs, input_symbol_names, input_symbol_values) for i in range(tf.shape(input_programs)[0]): self.assertAllEqual(util.from_tensor(expected_batch_programs[i]), util.from_tensor(test_batch_programs[i])) self.assertAllEqual(expected_new_symbol_names, test_new_symbol_names) self.assertAllClose(expected_batch_symbol_values, test_batch_symbol_values, atol=1e-5) self.assertAllClose(expected_batch_weights, test_batch_weights, atol=1e-5) self.assertAllEqual(expected_batch_mapper, test_batch_mapper)
def test_controls(): a, b = cirq.LineQubit.range(2) assert_url_to_circuit_returns( '{"cols":[["•","X"]]}', cirq.Circuit(cirq.X(b).controlled_by(a), ), ) assert_url_to_circuit_returns( '{"cols":[["◦","X"]]}', cirq.Circuit( cirq.X(a), cirq.X(b).controlled_by(a), cirq.X(a), ), ) assert_url_to_circuit_returns( '{"cols":[["⊕","X"]]}', cirq.Circuit( cirq.Y(a)**0.5, cirq.X(b).controlled_by(a), cirq.Y(a)**-0.5, ), output_amplitudes_from_quirk=[ { "r": 0.5, "i": 0 }, { "r": -0.5, "i": 0 }, { "r": 0.5, "i": 0 }, { "r": 0.5, "i": 0 }, ], ) assert_url_to_circuit_returns( '{"cols":[["⊖","X"]]}', cirq.Circuit( cirq.Y(a)**-0.5, cirq.X(b).controlled_by(a), cirq.Y(a)**+0.5, ), output_amplitudes_from_quirk=[ { "r": 0.5, "i": 0 }, { "r": 0.5, "i": 0 }, { "r": 0.5, "i": 0 }, { "r": -0.5, "i": 0 }, ], ) assert_url_to_circuit_returns( '{"cols":[["⊗","X"]]}', cirq.Circuit( cirq.X(a)**-0.5, cirq.X(b).controlled_by(a), cirq.X(a)**+0.5, ), output_amplitudes_from_quirk=[ { "r": 0.5, "i": 0 }, { "r": 0, "i": -0.5 }, { "r": 0.5, "i": 0 }, { "r": 0, "i": 0.5 }, ], ) assert_url_to_circuit_returns( '{"cols":[["(/)","X"]]}', cirq.Circuit( cirq.X(a)**+0.5, cirq.X(b).controlled_by(a), cirq.X(a)**-0.5, ), output_amplitudes_from_quirk=[ { "r": 0.5, "i": 0 }, { "r": 0, "i": 0.5 }, { "r": 0.5, "i": 0 }, { "r": 0, "i": -0.5 }, ], ) qs = cirq.LineQubit.range(8) assert_url_to_circuit_returns( '{"cols":[["X","•","◦","⊕","⊖","⊗","(/)","Z"]]}', cirq.Circuit( cirq.X(qs[2]), cirq.Y(qs[3])**0.5, cirq.Y(qs[4])**-0.5, cirq.X(qs[5])**-0.5, cirq.X(qs[6])**0.5, cirq.X(qs[0]).controlled_by(*qs[1:7]), cirq.Z(qs[7]).controlled_by(*qs[1:7]), cirq.X(qs[6])**-0.5, cirq.X(qs[5])**0.5, cirq.Y(qs[4])**0.5, cirq.Y(qs[3])**-0.5, cirq.X(qs[2]), ), )
from google.protobuf.text_format import Merge import cirq import cirq_google import cirq_google as cg from cirq_google.api import v1, v2 from cirq_google.engine import util from cirq_google.cloud import quantum from cirq_google.engine.engine import EngineContext _CIRCUIT = cirq.Circuit( cirq.X(cirq.GridQubit(5, 2))**0.5, cirq.measure(cirq.GridQubit(5, 2), key='result')) _CIRCUIT2 = cirq.FrozenCircuit( cirq.Y(cirq.GridQubit(5, 2))**0.5, cirq.measure(cirq.GridQubit(5, 2), key='result')) def _to_timestamp(json_string): timestamp_proto = timestamp_pb2.Timestamp() timestamp_proto.FromJsonString(json_string) return timestamp_proto _A_RESULT = util.pack_any( Merge( """ sweep_results: [{ repetitions: 1, measurement_keys: [{
def test_immutable_moment(): with pytest.raises(AttributeError): q1, q2 = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.X(q1)) moment = circuit.moments[0] moment.operations += (cirq.Y(q2),)
'LineQubit': [cirq.LineQubit(0), cirq.LineQubit(123)], 'LineQid': [cirq.LineQid(0, 1), cirq.LineQid(123, 2), cirq.LineQid(-4, 5)], 'MeasurementGate': [ cirq.MeasurementGate(num_qubits=3, key='z'), cirq.MeasurementGate(num_qubits=3, key='z', invert_mask=(True, False, True)), cirq.MeasurementGate(num_qubits=3, key='z', invert_mask=(True, False), qid_shape=(1, 2, 3)), ], 'Moment': [ cirq.Moment(operations=[cirq.X(Q0), cirq.Y(Q1), cirq.Z(Q2)]), ], 'NO_NOISE': cirq.NO_NOISE, 'NamedQubit': cirq.NamedQubit('hi mom'), 'PauliString': [ cirq.PauliString({ Q0: cirq.X, Q1: cirq.Y, Q2: cirq.Z }), cirq.X(Q0) * cirq.Y(Q1) * 123 ], 'PhaseDampingChannel':
for i, gate in enumerate(gates): a += gate b -= gate prefix = gates[:i + 1] expected_a = cirq.LinearCombinationOfGates(collections.Counter(prefix)) expected_b = -expected_a assert_linear_combinations_are_equal(a, expected_a) assert_linear_combinations_are_equal(b, expected_b) @pytest.mark.parametrize('op', ( cirq.X(q0), cirq.Y(q1), cirq.XX(q0, q1), cirq.CZ(q0, q1), cirq.FREDKIN(q0, q1, q2), cirq.ControlledOperation((q0, q1), cirq.H(q2)), cirq.ParallelGateOperation(cirq.X, (q0, q1, q2)), cirq.PauliString({ q0: cirq.X, q1: cirq.Y, q2: cirq.Z }), )) def test_empty_linear_combination_of_operations_accepts_all_operations(op): combination = cirq.LinearCombinationOfOperations({}) combination[op] = -0.5j assert len(combination) == 1
def cirq_op(self, x): return cirq.Y(x)
def two_qubit_ops( target_qubits: List[cirq.GridQubit], matrix: np.ndarray) -> Tuple[cirq.OP_TREE, List[cirq.GridQubit]]: a = target_qubits[0] b = target_qubits[1] #return [cirq.CNOT(a,b)],[] circs = [] circs2 = [] #circs.append( ([cirq.CNOT(a,b)],[]) )#For CNOT #circs.append( ([ cirq.Z(a)**(1.5),cirq.X(b)**(0.5),cirq.Z(b)**(0.5),cirq.ISWAP(a,b)**0.5,cirq.ISWAP(a,b)**0.5,cirq.X(a)**(0.5),cirq.ISWAP(a,b)**0.5,cirq.ISWAP(a,b)**0.5,cirq.Z(b) **0.5 ] , []) ) circs2.append(([cirq.CNOT(a, b)], [])) #For CNOT circs.append(([cirq.CNOT(a, b)], [])) #For CNOT circs.append(([cirq.CNOT(b, a), cirq.X(b)], [])) circs2.append(([cirq.CNOT(b, a), cirq.X(b)], [])) circs.append(([cirq.google.SYC(a, b)], [])) circs2.append(([cirq.google.SYC(a, b)], [])) circs.append(([cirq.google.SYC(b, a)], [])) circs2.append(([cirq.google.SYC(b, a)], [])) circs.append(([cirq.X(a), cirq.X(b)], [])) circs2.append(([cirq.X(a), cirq.X(b)], [])) circs.append(([cirq.Y(a), cirq.Y(b)], [])) circs2.append(([cirq.Y(a), cirq.Y(b)], [])) circs.append(([cirq.Z(a), cirq.Z(b)], [])) circs2.append(([cirq.Z(a), cirq.Z(b)], [])) circs.append(([], [])) circs2.append(([], [])) first = True for i, circ in enumerate(circs): list, ancilla = circs2[i] unit = cirq.unitary(cirq.Circuit(list)) if first: #print(matrix) first = False if np.allclose(matrix, unit, atol=0.00001): return circ #rint (np.array_str(matrix)) ''' for gate in [cirq.X,cirq.Y,cirq.Z]: if np.allclose(matrix, (cirq.unitary(gate)),atol=0.00001) : return [gate(a)],[] for gate in [cirq.H]:#,cirq.Y,cirq.Z]: if np.allclose(matrix, (cirq.unitary(gate)),atol=0.00001) : return [cirq.Z(a),cirq.Y(a)**0.5],[] for gate in [cirq.S]:#,cirq.Y,cirq.Z]: if np.allclose(matrix, (cirq.unitary(gate)),atol=0.00001) : return [cirq.Z(a)**0.5],[] for gate in [cirq.T]:#,cirq.Y,cirq.Z]: if np.allclose(matrix, (cirq.unitary(gate)),atol=0.00001) : return [cirq.Z(a)**0.25],[] ''' return [], []
def test_tagged_operation_forwards_protocols(): """The results of all protocols applied to an operation with a tag should be equivalent to the result without tags. """ q1 = cirq.GridQubit(1, 1) q2 = cirq.GridQubit(1, 2) h = cirq.H(q1) tag = 'tag1' tagged_h = cirq.H(q1).with_tags(tag) np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h)) assert cirq.has_unitary(tagged_h) assert cirq.decompose(tagged_h) == cirq.decompose(h) assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h) assert cirq.equal_up_to_global_phase(h, tagged_h) assert np.isclose(cirq.kraus(h), cirq.kraus(tagged_h)).all() assert cirq.measurement_key(cirq.measure( q1, key='blah').with_tags(tag)) == 'blah' parameterized_op = cirq.XPowGate( exponent=sympy.Symbol('t'))(q1).with_tags(tag) assert cirq.is_parameterized(parameterized_op) resolver = cirq.study.ParamResolver({'t': 0.25}) assert cirq.resolve_parameters( parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(q1).with_tags(tag) assert cirq.resolve_parameters_once( parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(q1).with_tags(tag) y = cirq.Y(q1) tagged_y = cirq.Y(q1).with_tags(tag) assert tagged_y**0.5 == cirq.YPowGate(exponent=0.5)(q1) assert tagged_y * 2 == (y * 2) assert 3 * tagged_y == (3 * y) assert cirq.phase_by(y, 0.125, 0) == cirq.phase_by(tagged_y, 0.125, 0) controlled_y = tagged_y.controlled_by(q2) assert controlled_y.qubits == ( q2, q1, ) assert isinstance(controlled_y, cirq.Operation) assert not isinstance(controlled_y, cirq.TaggedOperation) clifford_x = cirq.SingleQubitCliffordGate.X(q1) tagged_x = cirq.SingleQubitCliffordGate.X(q1).with_tags(tag) assert cirq.commutes(clifford_x, clifford_x) assert cirq.commutes(tagged_x, clifford_x) assert cirq.commutes(clifford_x, tagged_x) assert cirq.commutes(tagged_x, tagged_x) assert cirq.trace_distance_bound(y**0.001) == cirq.trace_distance_bound( (y**0.001).with_tags(tag)) flip = cirq.bit_flip(0.5)(q1) tagged_flip = cirq.bit_flip(0.5)(q1).with_tags(tag) assert cirq.has_mixture(tagged_flip) assert cirq.has_kraus(tagged_flip) flip_mixture = cirq.mixture(flip) tagged_mixture = cirq.mixture(tagged_flip) assert len(tagged_mixture) == 2 assert len(tagged_mixture[0]) == 2 assert len(tagged_mixture[1]) == 2 assert tagged_mixture[0][0] == flip_mixture[0][0] assert np.isclose(tagged_mixture[0][1], flip_mixture[0][1]).all() assert tagged_mixture[1][0] == flip_mixture[1][0] assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all() qubit_map = {q1: 'q1'} qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map) assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args) cirq.testing.assert_has_consistent_apply_unitary(tagged_h)
) results = cirq.read_json(f'{tmpdir}/obs.json') (result, ) = results # one group assert result.n_repetitions == 1_000 assert result.means() == [1.0] Q = cirq.NamedQubit('q') @pytest.mark.parametrize( ['circuit', 'observable'], [ (cirq.Circuit(cirq.X(Q)**0.2), cirq.Z(Q)), (cirq.Circuit(cirq.X(Q)**-0.5, cirq.Z(Q)**0.2), cirq.Y(Q)), (cirq.Circuit(cirq.Y(Q)**0.5, cirq.Z(Q)**0.2), cirq.X(Q)), ], ) def test_XYZ_point8(circuit, observable): # each circuit, observable combination should result in the observable value of 0.8 df = measure_observables_df( circuit, [observable], cirq.Simulator(seed=52), stopping_criteria=VarianceStoppingCriteria(1e-3**2), ) assert len(df) == 1, 'one observable' mean = df.loc[0]['mean'] np.testing.assert_allclose(0.8, mean, atol=1e-2)
def default_decompose(self, qubits): yield cirq.X(qubits[0]) yield cirq.Y(qubits[0])**0.5
def _decompose_(self): yield cirq.X(cirq.LineQubit(0)) yield cirq.Y(cirq.LineQubit(1))
def _decompose_(self, qubits): q0, q1 = qubits yield cirq.X(q0) yield cirq.Y(q1)**0.5 yield cirq.H(q0)
def test_cirq_qsim_all_supported_gates(self): q0 = cirq.GridQubit(1, 1) q1 = cirq.GridQubit(1, 0) q2 = cirq.GridQubit(0, 1) q3 = cirq.GridQubit(0, 0) circuit = cirq.Circuit( cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), cirq.Moment([ cirq.T(q0), cirq.T(q1), cirq.T(q2), cirq.T(q3), ]), cirq.Moment([ cirq.CZPowGate(exponent=0.7, global_shift=0.2)(q0, q1), cirq.CXPowGate(exponent=1.2, global_shift=0.4)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.3, global_shift=1.1)(q0), cirq.YPowGate(exponent=0.4, global_shift=1)(q1), cirq.ZPowGate(exponent=0.5, global_shift=0.9)(q2), cirq.HPowGate(exponent=0.6, global_shift=0.8)(q3), ]), cirq.Moment([ cirq.CX(q0, q2), cirq.CZ(q1, q3), ]), cirq.Moment([ cirq.X(q0), cirq.Y(q1), cirq.Z(q2), cirq.S(q3), ]), cirq.Moment([ cirq.XXPowGate(exponent=0.4, global_shift=0.7)(q0, q1), cirq.YYPowGate(exponent=0.8, global_shift=0.5)(q2, q3), ]), cirq.Moment([cirq.I(q0), cirq.I(q1), cirq.IdentityGate(2)(q2, q3)]), cirq.Moment([ cirq.rx(0.7)(q0), cirq.ry(0.2)(q1), cirq.rz(0.4)(q2), cirq.PhasedXPowGate(phase_exponent=0.8, exponent=0.6, global_shift=0.3)(q3), ]), cirq.Moment([ cirq.ZZPowGate(exponent=0.3, global_shift=1.3)(q0, q2), cirq.ISwapPowGate(exponent=0.6, global_shift=1.2)(q1, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.1, global_shift=0.9)(q0), cirq.YPowGate(exponent=0.2, global_shift=1)(q1), cirq.ZPowGate(exponent=0.3, global_shift=1.1)(q2), cirq.HPowGate(exponent=0.4, global_shift=1.2)(q3), ]), cirq.Moment([ cirq.SwapPowGate(exponent=0.2, global_shift=0.9)(q0, q1), cirq.PhasedISwapPowGate(phase_exponent=0.8, exponent=0.6)(q2, q3), ]), cirq.Moment([ cirq.PhasedXZGate(x_exponent=0.2, z_exponent=0.3, axis_phase_exponent=1.4)(q0), cirq.T(q1), cirq.H(q2), cirq.S(q3), ]), cirq.Moment([ cirq.SWAP(q0, q2), cirq.XX(q1, q3), ]), cirq.Moment([ cirq.rx(0.8)(q0), cirq.ry(0.9)(q1), cirq.rz(1.2)(q2), cirq.T(q3), ]), cirq.Moment([ cirq.YY(q0, q1), cirq.ISWAP(q2, q3), ]), cirq.Moment([ cirq.T(q0), cirq.Z(q1), cirq.Y(q2), cirq.X(q3), ]), cirq.Moment([ cirq.FSimGate(0.3, 1.7)(q0, q2), cirq.ZZ(q1, q3), ]), cirq.Moment([ cirq.ry(1.3)(q0), cirq.rz(0.4)(q1), cirq.rx(0.7)(q2), cirq.S(q3), ]), cirq.Moment([ cirq.IdentityGate(4).on(q0, q1, q2, q3), ]), cirq.Moment([ cirq.CCZPowGate(exponent=0.7, global_shift=0.3)(q2, q0, q1), ]), cirq.Moment([ cirq.CCXPowGate(exponent=0.4, global_shift=0.6)( q3, q1, q0).controlled_by(q2, control_values=[0]), ]), cirq.Moment([ cirq.rx(0.3)(q0), cirq.ry(0.5)(q1), cirq.rz(0.7)(q2), cirq.rx(0.9)(q3), ]), cirq.Moment([ cirq.TwoQubitDiagonalGate([0.1, 0.2, 0.3, 0.4])(q0, q1), ]), cirq.Moment([ cirq.ThreeQubitDiagonalGate( [0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2, 1.3])(q1, q2, q3), ]), cirq.Moment([ cirq.CSwapGate()(q0, q3, q1), ]), cirq.Moment([ cirq.rz(0.6)(q0), cirq.rx(0.7)(q1), cirq.ry(0.8)(q2), cirq.rz(0.9)(q3), ]), cirq.Moment([ cirq.TOFFOLI(q3, q2, q0), ]), cirq.Moment([ cirq.FREDKIN(q1, q3, q2), ]), cirq.Moment([ cirq.MatrixGate( np.array([[0, -0.5 - 0.5j, -0.5 - 0.5j, 0], [0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j], [0, -0.5 - 0.5j, 0.5 + 0.5j, 0]]))(q0, q1), cirq.MatrixGate( np.array([[0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0, 0.5 - 0.5j, -0.5 + 0.5j, 0], [0, -0.5 + 0.5j, -0.5 + 0.5j, 0], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j]]))(q2, q3), ]), cirq.Moment([ cirq.MatrixGate(np.array([[1, 0], [0, 1j]]))(q0), cirq.MatrixGate(np.array([[0, -1j], [1j, 0]]))(q1), cirq.MatrixGate(np.array([[0, 1], [1, 0]]))(q2), cirq.MatrixGate(np.array([[1, 0], [0, -1]]))(q3), ]), cirq.Moment([ cirq.riswap(0.7)(q0, q1), cirq.givens(1.2)(q2, q3), ]), cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), ) simulator = cirq.Simulator() cirq_result = simulator.simulate(circuit) qsim_simulator = qsimcirq.QSimSimulator() qsim_result = qsim_simulator.simulate(circuit) assert cirq.linalg.allclose_up_to_global_phase( qsim_result.state_vector(), cirq_result.state_vector())
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest import cirq from cirq.contrib.paulistring import converted_gate_set @pytest.mark.parametrize( 'op,expected_ops', (lambda q0, q1: ( (cirq.X(q0), cirq.SingleQubitCliffordGate.X(q0)), (cirq.Y(q0), cirq.SingleQubitCliffordGate.Y(q0)), (cirq.Z(q0), cirq.SingleQubitCliffordGate.Z(q0)), (cirq.X(q0)**0.5, cirq.SingleQubitCliffordGate.X_sqrt(q0)), (cirq.Y(q0)**0.5, cirq.SingleQubitCliffordGate.Y_sqrt(q0)), (cirq.Z(q0)**0.5, cirq.SingleQubitCliffordGate.Z_sqrt(q0)), (cirq.X(q0)**-0.5, cirq.SingleQubitCliffordGate.X_nsqrt(q0)), (cirq.Y(q0)**-0.5, cirq.SingleQubitCliffordGate.Y_nsqrt(q0)), (cirq.Z(q0)**-0.5, cirq.SingleQubitCliffordGate.Z_nsqrt(q0)), (cirq.X(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.X.on(q0)]))**0.25), (cirq.Y(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.Y.on(q0)]))**0.25), (cirq.Z(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString([cirq.Z.on(q0)]))**0.25), (cirq.X(q0)**0, ()), (cirq.CZ(q0, q1), cirq.CZ(q0, q1)),
def _decompose_(self, qubits): yield cirq.X(qubits[0]) yield cirq.Y(qubits[0])**0.5
def _all_operations(q0, q1, q2, q3, q4, include_measurements=True): class DummyOperation(cirq.Operation): qubits = (q0,) with_qubits = NotImplemented def _qasm_(self, args: cirq.QasmArgs) -> str: return '// Dummy operation\n' def _decompose_(self): # Only used by test_output_unitary_same_as_qiskit return () # coverage: ignore class DummyCompositeOperation(cirq.Operation): qubits = (q0,) with_qubits = NotImplemented def _decompose_(self): return cirq.X(self.qubits[0]) def __repr__(self): return 'DummyCompositeOperation()' return ( cirq.Z(q0), cirq.Z(q0) ** 0.625, cirq.Y(q0), cirq.Y(q0) ** 0.375, cirq.X(q0), cirq.X(q0) ** 0.875, cirq.H(q1), cirq.CZ(q0, q1), cirq.CZ(q0, q1) ** 0.25, # Requires 2-qubit decomposition cirq.CNOT(q0, q1), cirq.CNOT(q0, q1) ** 0.5, # Requires 2-qubit decomposition cirq.SWAP(q0, q1), cirq.SWAP(q0, q1) ** 0.75, # Requires 2-qubit decomposition cirq.CCZ(q0, q1, q2), cirq.CCX(q0, q1, q2), cirq.CCZ(q0, q1, q2) ** 0.5, cirq.CCX(q0, q1, q2) ** 0.5, cirq.CSWAP(q0, q1, q2), cirq.IdentityGate(1).on(q0), cirq.IdentityGate(3).on(q0, q1, q2), cirq.ISWAP(q2, q0), # Requires 2-qubit decomposition cirq.PhasedXPowGate(phase_exponent=0.111, exponent=0.25).on(q1), cirq.PhasedXPowGate(phase_exponent=0.333, exponent=0.5).on(q1), cirq.PhasedXPowGate(phase_exponent=0.777, exponent=-0.5).on(q1), ( cirq.measure(q0, key='xX'), cirq.measure(q2, key='x_a'), cirq.measure(q1, key='x?'), cirq.measure(q3, key='X'), cirq.measure(q4, key='_x'), cirq.measure(q2, key='x_a'), cirq.measure(q1, q2, q3, key='multi', invert_mask=(False, True)), ) if include_measurements else (), DummyOperation(), DummyCompositeOperation(), )