def test_query_point_operation_inclusive(): q = ops.QubitId() zero = Timestamp(picos=0) ps = Duration(picos=1) op = ScheduledOperation(zero, Duration(), ops.H(q)) schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op]) def query(t, d=Duration(), qubits=None): return schedule.query(time=t, duration=d, qubits=qubits, include_query_end_time=True, include_op_end_times=True) assert query(zero) == [op] assert query(zero + ps) == [] assert query(zero - ps) == [] assert query(zero, qubits=[]) == [] assert query(zero, qubits=[q]) == [op] assert query(zero, ps) == [op] assert query(zero - 0.5 * ps, ps) == [op] assert query(zero - ps, ps) == [op] assert query(zero - 2 * ps, ps) == [] assert query(zero - ps, 3 * ps) == [op] assert query(zero + ps, ps) == []
def test_init(): r = ScheduledOperation(time=Timestamp(picos=5), duration=Duration(picos=7), operation=cirq.H(cirq.NamedQubit('a'))) assert r.time == Timestamp(picos=5) assert r.duration == Duration(picos=7) assert r.operation == cirq.H(cirq.NamedQubit('a'))
def test_repr(): a = Duration(picos=1000, nanos=1000) cirq.testing.assert_equivalent_repr(a) b = Duration(picos=5000) cirq.testing.assert_equivalent_repr(b) c = Duration(nanos=1.0) cirq.testing.assert_equivalent_repr(c)
def test_query_point_operation_exclusive(): q = ops.QubitId() zero = Timestamp(picos=0) ps = Duration(picos=1) op = ScheduledOperation(zero, Duration(), ops.H(q)) schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op]) assert schedule.query(time=zero, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero + ps, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero - ps, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero) == [] assert schedule.query(time=zero + ps) == [] assert schedule.query(time=zero - ps) == [] assert schedule.query(time=zero, qubits=[]) == [] assert schedule.query(time=zero, qubits=[q]) == [] assert schedule.query(time=zero, duration=ps) == [] assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op] assert schedule.query(time=zero - ps, duration=ps) == [] assert schedule.query(time=zero - 2 * ps, duration=ps) == [] assert schedule.query(time=zero - ps, duration=3 * ps) == [op] assert schedule.query(time=zero + ps, duration=ps) == []
def duration_of(self, operation: ops.Operation) -> Duration: g = operation.gate if isinstance(g, ops.HGate): return Duration(nanos=20) elif isinstance(g, ops.Rot11Gate): return Duration(nanos=40) else: raise ValueError('Unsupported gate type {}'.format(repr(g)))
def test_init(): r = ScheduledOperation(time=Timestamp(picos=5), duration=Duration(picos=7), operation=ops.Operation(ops.H, [ops.NamedQubit('a')])) assert r.time == Timestamp(picos=5) assert r.duration == Duration(picos=7) assert r.operation == ops.Operation(ops.H, [ops.NamedQubit('a')])
def test_cmp_vs_other_type(): with pytest.raises(TypeError): _ = Duration() < 0 with pytest.raises(TypeError): _ = Duration() <= 0 with pytest.raises(TypeError): _ = Duration() >= 0 with pytest.raises(TypeError): _ = Duration() > 0
def test_eq(): eq = cirq.testing.EqualsTester() eq.add_equality_group(Duration(), Duration(picos=0), Duration(nanos=0.0), timedelta(0)) eq.add_equality_group(Duration(picos=1000), Duration(nanos=1)) eq.make_equality_group(lambda: Duration(picos=-1)) eq.add_equality_group(Duration(micros=5.0), Duration(micros=5), timedelta(0, 0, 5)) # Can't hash match 0, but no-duration is equal to 0. assert Duration() == 0 assert Duration(picos=1) != 0
def test_eq(): q0 = ops.QubitId() eq = EqualsTester() eq.make_equality_pair( lambda: ScheduledOperation(Timestamp(), Duration(), ops.H(q0))) eq.make_equality_pair( lambda: ScheduledOperation(Timestamp(picos=5), Duration(), ops.H(q0))) eq.make_equality_pair( lambda: ScheduledOperation(Timestamp(), Duration(picos=5), ops.H(q0))) eq.make_equality_pair( lambda: ScheduledOperation(Timestamp(), Duration(), ops.X(q0)))
def test_eq(): q0 = cirq.QubitId() eq = EqualsTester() eq.make_equality_group( lambda: ScheduledOperation(Timestamp(), Duration(), cirq.H(q0))) eq.make_equality_group( lambda: ScheduledOperation(Timestamp(picos=5), Duration(), cirq.H(q0))) eq.make_equality_group( lambda: ScheduledOperation(Timestamp(), Duration(picos=5), cirq.H(q0))) eq.make_equality_group( lambda: ScheduledOperation(Timestamp(), Duration(), cirq.X(q0)))
def test_parameterized(resolve_fn): t = sympy.Symbol('t') assert not cirq.is_parameterized(Duration()) assert not cirq.is_parameterized(Duration(nanos=500)) assert cirq.is_parameterized(Duration(nanos=500 * t)) assert resolve_fn(Duration(), {'t': 2}) == Duration() assert resolve_fn(Duration(nanos=500), {'t': 2}) == Duration(nanos=500) assert resolve_fn(Duration(nanos=500 * t), {'t': 2}) == Duration(nanos=1000)
def test_init(): assert Duration().total_picos() == 0 assert Duration(picos=513).total_picos() == 513 assert Duration(picos=-5).total_picos() == -5 assert Duration(nanos=211).total_picos() == 211000 assert Duration(nanos=211, picos=1051).total_picos() == 212051 assert isinstance(Duration(picos=1).total_picos(), int) assert isinstance(Duration(nanos=1).total_picos(), int) assert isinstance(Duration(picos=1.0).total_picos(), float) assert isinstance(Duration(nanos=1.0).total_picos(), float)
def test_sub(): assert Duration() - Duration() == Duration() assert Duration(picos=1) - Duration(picos=2) == Duration(picos=-1) with pytest.raises(TypeError): _ = 1 - Duration() with pytest.raises(TypeError): _ = Duration() - 1
def test_add(): assert Duration() + Duration() == Duration() assert Duration(picos=1) + Duration(picos=2) == Duration(picos=3) with pytest.raises(TypeError): _ = 1 + Duration() with pytest.raises(TypeError): _ = Duration() + 1
def __init__( self, measurement_duration: 'cirq.DURATION_LIKE', gate_duration: 'cirq.DURATION_LIKE', control_radius: float, max_parallel_z: int, max_parallel_xy: int, max_parallel_c: int, qubits: Iterable[GridQubit], ) -> None: """ Initializes the description of the AQuA device. Args: measurement_duration: the maximum duration of a measurement. gate_duration: the maximum duration of a gate control_radius: the maximum distance between qubits for a controlled gate. Distance is measured in units of the indices passed into the GridQubit constructor. max_parallel_z: The maximum number of qubits that can be acted on in parallel by a Z gate max_parallel_xy: The maximum number of qubits that can be acted on in parallel by a local XY gate max_parallel_c: the maximum number of qubits that can be acted on in parallel by a controlled gate. Must be less than or equal to the lesser of max_parallel_z and max_parallel_xy qubits: Qubits on the device, identified by their x, y location. Must be of type GridQubit Raises: ValueError: if the wrong qubit type is provided or if invalid parallel parameters are provided """ self._measurement_duration = Duration(measurement_duration) self._gate_duration = Duration(gate_duration) self._control_radius = control_radius self._max_parallel_z = max_parallel_z self._max_parallel_xy = max_parallel_xy if max_parallel_c > min(max_parallel_z, max_parallel_xy): raise ValueError( "max_parallel_c must be less than or equal to the" "min of max_parallel_z and max_parallel_xy" ) self._max_parallel_c = max_parallel_c for q in qubits: if not isinstance(q, GridQubit): raise ValueError('Unsupported qubit type: {!r}'.format(q)) self.qubits = frozenset(qubits)
def from_proto( cls, proto: v2.device_pb2.DeviceSpecification, gate_set: serializable_gate_set.SerializableGateSet ) -> 'SerializableDevice': """ Args: proto: A proto describing the qubits on the device, as well as the supported gates and timing information. gate_set: A SerializableGateSet that can translate the gate_ids into cirq Gates. """ # Store target sets, since they are refered to by name later allowed_targets: Dict[str, Set[Tuple['cirq.Qid', ...]]] = {} permutation_ids: Set[str] = set() for ts in proto.valid_targets: allowed_targets[ts.name] = cls._create_target_set(ts) if ts.target_ordering == v2.device_pb2.TargetSet.SUBSET_PERMUTATION: permutation_ids.add(ts.name) # Store gate definitions from proto gate_definitions: Dict[str, _GateDefinition] = {} for gs in proto.valid_gate_sets: for gate_def in gs.valid_gates: # Combine all valid targets in the gate's listed target sets gate_target_set = set([ target for ts_name in gate_def.valid_targets for target in allowed_targets[ts_name] ]) which_are_permutations = [ t in permutation_ids for t in gate_def.valid_targets ] is_permutation = any(which_are_permutations) if is_permutation: if not all(which_are_permutations): msg = f'Id {gate_def.id} in {gate_set.gate_set_name} ' \ ' mixes SUBSET_PERMUTATION with other types which' \ ' is not currently allowed.' raise NotImplementedError(msg) gate_definitions[gate_def.id] = _GateDefinition( duration=Duration(picos=gate_def.gate_duration_picos), target_set=gate_target_set, is_permutation=is_permutation, number_of_qubits=gate_def.number_of_qubits) # Loop through serializers and map gate_definitions to type gates_by_type: Dict[Type['cirq.Gate'], _GateDefinition] = {} for gate_type in gate_set.supported_gate_types(): for serializer in gate_set.serializers[gate_type]: gate_id = serializer.serialized_gate_id if gate_id not in gate_definitions: raise ValueError(f'Serializer has {gate_id} which is not ' 'supported by the device specification') gates_by_type[gate_type] = gate_definitions[gate_id] return SerializableDevice( qubits=SerializableDevice._qubits_from_ids(proto.valid_qubits), gate_definitions=gates_by_type, )
def test_init_timedelta(): r = ScheduledOperation(time=Timestamp(picos=5), duration=timedelta(microseconds=7), operation=cirq.H(cirq.NamedQubit('a'))) assert r.time == Timestamp(picos=5) assert r.duration == Duration(picos=7 * 10**6) assert r.operation == cirq.H(cirq.NamedQubit('a'))
def test_greedy_method_calls_greedy_search(): q00 = XmonQubit(0, 0) q01 = XmonQubit(0, 1) q03 = XmonQubit(0, 3) device = XmonDevice(Duration(nanos=0), Duration(nanos=0), Duration(nanos=0), qubits=[q00, q01, q03]) method = greedy.GreedySequenceSearchMethod() with mock.patch.object(method, 'place_line') as place_line: sequences = [[q00, q01]] place_line.return_value = sequences assert place_on_device(device, method) == sequences place_line.assert_called_once_with(device)
def test_query_overlapping_operations_inclusive(): q = ops.QubitId() zero = Timestamp(picos=0) ps = Duration(picos=1) op1 = ScheduledOperation(zero, 2 * ps, ops.H(q)) op2 = ScheduledOperation(zero + ps, 2 * ps, ops.H(q)) schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op2, op1]) def query(t, d=Duration(), qubits=None): return schedule.query(time=t, duration=d, qubits=qubits, include_query_end_time=True, include_op_end_times=True) assert query(zero - 0.5 * ps, ps) == [op1] assert query(zero - 0.5 * ps, 2 * ps) == [op1, op2] assert query(zero, ps) == [op1, op2] assert query(zero + 0.5 * ps, ps) == [op1, op2] assert query(zero + ps, ps) == [op1, op2] assert query(zero + 1.5 * ps, ps) == [op1, op2] assert query(zero + 2.0 * ps, ps) == [op1, op2] assert query(zero + 2.5 * ps, ps) == [op2] assert query(zero + 3.0 * ps, ps) == [op2] assert query(zero + 3.5 * ps, ps) == []
def query( self, *, # Forces keyword args. time: Timestamp, duration: Union[Duration, timedelta] = Duration(), qubits: Iterable[Qid] = None, include_query_end_time=False, include_op_end_times=False) -> List[ScheduledOperation]: """Finds operations by time and qubit. Args: time: Operations must end after this time to be returned. duration: Operations must start by time+duration to be returned. qubits: If specified, only operations touching one of the included qubits will be returned. include_query_end_time: Determines if the query interval includes its end time. Defaults to no. include_op_end_times: Determines if the scheduled operation intervals include their end times or not. Defaults to no. Returns: A list of scheduled operations meeting the specified conditions. """ duration = Duration.create(duration) earliest_time = time - self._max_duration end_time = time + duration qubits = None if qubits is None else frozenset(qubits) def overlaps_interval(op): if not include_op_end_times and op.time + op.duration == time: return False if not include_query_end_time and op.time == end_time: return False return op.time + op.duration >= time and op.time <= end_time def overlaps_qubits(op): if qubits is None: return True return not qubits.isdisjoint(op.operation.qubits) potential_matches = self.scheduled_operations.irange_key( earliest_time, end_time) return [ op for op in potential_matches if overlaps_interval(op) and overlaps_qubits(op) ]
def test_str(): assert str(Duration(picos=-2)) == '-2 ps' assert str(Duration()) == 'Duration(0)' assert str(Duration(picos=2)) == '2 ps' assert str(Duration(nanos=2)) == '2 ns' assert str(Duration(micros=2)) == '2 us' assert str(Duration(millis=2)) == '2 ms' assert str(Duration(micros=1.5)) == '1500.0 ns' assert str(Duration(micros=1.5 * sympy.Symbol('t'))) == '(1500.0*t) ns'
def test_mul(): assert Duration(picos=2) * 3 == Duration(picos=6) assert 4 * Duration(picos=3) == Duration(picos=12) t = sympy.Symbol('t') assert t * Duration(picos=3) == Duration(picos=3 * t) with pytest.raises(TypeError): _ = Duration() * Duration()
def test_total(): assert Duration().total_nanos() == 0 assert Duration(picos=3000).total_nanos() == 3 assert Duration(nanos=5).total_nanos() == 5 assert Duration().total_nanos() == 0 assert Duration(picos=500).total_nanos() == 0.5 assert Duration(nanos=500).total_micros() == 0.5 assert Duration(micros=500).total_millis() == 0.5 assert Duration(millis=500).total_millis() == 500
def test_init_timedelta(): assert Duration(timedelta(microseconds=0)).total_picos() == 0 assert Duration(timedelta(microseconds=513)).total_picos() == 513 * 10**6 assert Duration(timedelta(microseconds=-5)).total_picos() == -5 * 10**6 assert Duration(timedelta(microseconds=211)).total_picos() == 211 * 10**6 assert Duration(timedelta(seconds=3)).total_picos() == 3 * 10**12 assert Duration(timedelta(seconds=-5)).total_picos() == -5 * 10**12 assert Duration(timedelta(seconds=3)).total_nanos() == 3 * 10**9 assert Duration(timedelta(seconds=-5)).total_nanos() == -5 * 10**9
def test_repr(): cirq.testing.assert_equivalent_repr(Duration(millis=2)) cirq.testing.assert_equivalent_repr(Duration(micros=2)) cirq.testing.assert_equivalent_repr(Duration(picos=1000, nanos=1000)) cirq.testing.assert_equivalent_repr(Duration(picos=5000)) cirq.testing.assert_equivalent_repr(Duration(nanos=1.0)) cirq.testing.assert_equivalent_repr(Duration(micros=sympy.Symbol('t'))) cirq.testing.assert_equivalent_repr(Duration(micros=1.5 * sympy.Symbol('t')))
def square_device(width, height, holes=()): ns = Duration(nanos=1) return XmonDevice(measurement_duration=ns, exp_w_duration=2 * ns, exp_11_duration=3 * ns, qubits=[ XmonQubit(x, y) for x in range(width) for y in range(height) if XmonQubit(x, y) not in holes ])
def simple_schedule(q, start_picos=0, duration_picos=1, num_ops=1): time_picos = start_picos scheduled_ops = [] for _ in range(num_ops): op = ScheduledOperation(Timestamp(picos=time_picos), Duration(picos=duration_picos), ops.H(q)) scheduled_ops.append(op) time_picos += duration_picos return Schedule(device=UnconstrainedDevice, scheduled_operations=scheduled_ops)
def duration_of(self, operation): g = xmon_gate_ext.try_cast(operation.gate, xmon_gates.XmonGate) if isinstance(g, xmon_gates.Exp11Gate): return self._exp_z_duration if isinstance(g, xmon_gates.ExpWGate): return self._exp_w_duration if isinstance(g, xmon_gates.XmonMeasurementGate): return self._measurement_duration if isinstance(g, xmon_gates.ExpZGate): return Duration() # Z gates are performed in the control software. raise ValueError('Unsupported gate type: {}'.format(repr(g)))
def __init__(self, time: Timestamp, duration: 'cirq.DURATION_LIKE', operation: ops.Operation) -> None: """Initializes the scheduled operation. Args: time: When the operation starts. duration: How long the operation lasts. operation: The operation. """ self.time = time self.duration = Duration(duration) self.operation = operation
def __init__(self, time: Timestamp, duration: Union[Duration, timedelta], operation: ops.Operation) -> None: """Initializes the scheduled operation. Args: time: When the operation starts. duration: How long the operation lasts. operation: The operation. """ self.time = time self.duration = Duration.create(duration) self.operation = operation