def test_correctness_3(self) -> None: circuit = Circuit(5) wide_gate = IdentityGate(3) circuit.append_gate(HGate(), [1]) circuit.append_gate(CNOTGate(), [2, 3]) circuit.append_gate(wide_gate, [1, 2, 3]) circuit.append_gate(CNOTGate(), [1, 2]) circuit.append_gate(HGate(), [3]) circuit.append_gate(XGate(), [0]) circuit.append_gate(XGate(), [0]) circuit.append_gate(XGate(), [0]) circuit.append_gate(XGate(), [4]) circuit.append_gate(XGate(), [4]) circuit.append_gate(XGate(), [4]) utry = circuit.get_unitary() circuit.fold(circuit.get_region([(0, 2), (1, 1), (2, 1)])) assert circuit.get_num_operations() == 9 assert circuit.get_depth() == 3 assert circuit.count(HGate()) == 2 assert circuit.count(XGate()) == 6 assert isinstance(circuit[1, 1].gate, CircuitGate) test_gate: CircuitGate = circuit[1, 1].gate assert test_gate._circuit[0, 1].gate is CNOTGate() assert test_gate._circuit[0, 2].gate is CNOTGate() assert test_gate._circuit[1, 0].gate is wide_gate assert test_gate._circuit[1, 1].gate is wide_gate assert test_gate._circuit[1, 2].gate is wide_gate check_no_idle_cycles(circuit) assert np.allclose(utry.get_numpy(), circuit.get_unitary().get_numpy())
def test_type_valid(self, points: Sequence[CircuitPointLike]) -> None: circuit = Circuit(4, [2, 2, 3, 3]) try: circuit.fold(circuit.get_region(points)) except TypeError: assert False, 'Unexpected TypeError.' except BaseException: return
def test_invalid_fold(self, points: Sequence[CircuitPointLike]) -> None: circuit = Circuit(4) wide_gate = IdentityGate(4) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) with pytest.raises(ValueError): circuit.fold(circuit.get_region(points))
def test_with_fold(self, r6_qudit_circuit: Circuit) -> None: cycle = 0 qudit = 0 while True: cycle = np.random.randint(r6_qudit_circuit.get_num_cycles()) qudit = np.random.randint(r6_qudit_circuit.get_size()) if not r6_qudit_circuit.is_point_idle((cycle, qudit)): break utry = r6_qudit_circuit.get_unitary() region = r6_qudit_circuit.surround((cycle, qudit), 4) r6_qudit_circuit.fold(region) assert r6_qudit_circuit.get_unitary() == utry
def test_parameters(self) -> None: circ = Circuit(2) circ.append_gate(CNOTGate(), [1, 0]) circ.append_gate(U3Gate(), [0], [0, 0, 0.23]) circ.append_gate(CNOTGate(), [1, 0]) before_fold = circ.get_unitary() circ.fold(circ.get_region([(0, 0), (1, 0), (2, 0)])) after_fold = circ.get_unitary() assert after_fold == before_fold
def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """ Partition gates in a circuit into a series of CircuitGates. Args: circuit (Circuit): Circuit to be partitioned. data (dict[str,Any]): Optional data unique to specific run. """ if self.block_size > circuit.get_size(): _logger.warning( 'Configured block size is greater than circuit size; ' 'blocking entire circuit.', ) circuit.fold({ qudit_index: (0, circuit.get_num_cycles()) for qudit_index in range(circuit.get_size()) }) return for i in range(self.num_points): # Pick best region of 4 random points best_region = None best_gates = 0 for _ in range(4): cycle = 0 qudit = 0 while True: cycle = np.random.randint(circuit.get_num_cycles()) qudit = np.random.randint(circuit.get_size()) if not circuit.is_point_idle((cycle, qudit)): break region = circuit.surround((cycle, qudit), self.block_size) num_gates = len(circuit[region]) if num_gates > best_gates: best_gates = num_gates best_region = region if best_region is None: raise RuntimeError('Unable to find a region.') circuit.fold(best_region)
def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """ Partition gates in a circuit into a series of CircuitGates. Args: circuit (Circuit): Circuit to be partitioned. data (dict[str,Any]): Optional data unique to specific run. """ if self.block_size > circuit.get_size(): _logger.warning( 'Configured block size is greater than circuit size; ' 'blocking entire circuit.', ) circuit.fold({ qudit_index: (0, circuit.get_num_cycles()) for qudit_index in range(circuit.get_size()) }) return # If a MachineModel is provided in the data dict, it will be used. # Otherwise all-to-all connectivity is assumed. model = None if 'machine_model' in data: model = data['machine_model'] if (not isinstance(model, MachineModel) or model.num_qudits < circuit.get_size()): _logger.warning( 'MachineModel not specified or invalid;' ' defaulting to all-to-all.', ) model = MachineModel(circuit.get_size()) # Find all connected, `block_size`-sized groups of qudits # NOTE: This assumes circuit and topology qudit numbers are equal qudit_groups = model.get_locations(self.block_size) # Prune unused qudit groups used_qudits = [ q for q in range(circuit.get_size()) if not circuit.is_qudit_idle(q) ] for qudit_group in qudit_groups: if all([q not in used_qudits for q in qudit_group]): qudit_groups.remove(qudit_group) # divider splits the circuit into partitioned and unpartitioned spaces. active_qudits = circuit.get_active_qudits() num_cycles = circuit.get_num_cycles() divider = [ 0 if q in active_qudits else num_cycles for q in range(circuit.get_size()) ] # Form regions until there are no more gates to partition regions: list[CircuitRegion] = [] while any(cycle < num_cycles for cycle in divider): # Move past/skip any gates that are larger than block size qudits_to_increment: list[int] = [] for qudit, cycle in enumerate(divider): if qudit in qudits_to_increment or cycle >= num_cycles: continue if not circuit.is_point_idle((cycle, qudit)): op = circuit[cycle, qudit] if len(op.location) > self.block_size: if all(divider[q] == cycle for q in op.location): qudits_to_increment.extend(op.location) _logger.warning( 'Skipping gate larger than block size.', ) if len(qudits_to_increment) > 0: regions.append( CircuitRegion( { qudit: (divider[qudit], divider[qudit]) for qudit in qudits_to_increment }, ), ) for qudit in qudits_to_increment: divider[qudit] += 1 # Skip any idle qudit-cycles amount_to_add_to_each_qudit = [ 0 for _ in range(circuit.get_size()) ] for qudit, cycle in enumerate(divider): while (cycle < num_cycles and circuit.is_point_idle( (cycle, qudit))): amount_to_add_to_each_qudit[qudit] += 1 cycle += 1 for qudit, amount in enumerate(amount_to_add_to_each_qudit): divider[qudit] += amount # Find the scores of the qudit groups. best_score = None best_region = None for qudit_group in qudit_groups: ops_and_cycles = circuit.operations_with_cycles( qudits_or_region=CircuitRegion({ qudit_index: (divider[qudit_index], num_cycles) for qudit_index in qudit_group }), ) in_qudits = list(q for q in qudit_group) stopped_cycles = {q: num_cycles for q in qudit_group} score = 0 for cycle, op in ops_and_cycles: if len(op.location.union(in_qudits)) != len(in_qudits): for qudit_index in op.location.intersection(in_qudits): stopped_cycles[qudit_index] = cycle in_qudits.remove(qudit_index) else: if len(op.location) > 1: score += self.multi_gate_score else: score += self.single_gate_score if len(in_qudits) == 0: break if best_score is None or score > best_score: best_score = score best_region = CircuitRegion({ qudit: ( divider[qudit], # Might have errors if below is removed stopped_cycles[qudit] - 1, ) for qudit in qudit_group # This statement # if stopped_cycles[qudit] - 1 >= divider[qudit] }) if best_score is None or best_region is None: raise RuntimeError('No valid block found.') _logger.info('Found block with score: %d.' % (best_score)) regions.append(best_region) # Update divider for qudit_index in best_region: divider[qudit_index] = best_region[qudit_index].upper + 1 # Fold the circuit folded_circuit = Circuit(circuit.get_size(), circuit.get_radixes()) # Option to keep a block's idle qudits as part of the CircuitGate if 'keep_idle_qudits' in data and data['keep_idle_qudits'] is True: for region in regions: small_region = circuit.downsize_region(region) cgc = circuit.get_slice(small_region.points) if len(region.location) > len(small_region.location): for i in range(len(region.location)): if region.location[i] not in small_region.location: cgc.insert_qudit(i) folded_circuit.append_gate( CircuitGate(cgc, True), sorted(list(region.keys())), list(cgc.get_params()), ) else: for region in regions: region = circuit.downsize_region(region) if 0 < len(region) <= self.block_size: cgc = circuit.get_slice(region.points) folded_circuit.append_gate( CircuitGate(cgc, True), sorted(list(region.keys())), list(cgc.get_params()), ) else: folded_circuit.extend(circuit[region]) circuit.become(folded_circuit)
def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """ Partition gates in a circuit into a series of CircuitGates. Args: circuit (Circuit): Circuit to be partitioned. data (dict[str,Any]): Optional data unique to specific run. """ if self.block_size > circuit.get_size(): _logger.warning( 'Configured block size is greater than circuit size; ' 'blocking entire circuit.', ) circuit.fold({ qudit_index: (0, circuit.get_num_cycles()) for qudit_index in range(circuit.get_size()) }) return # If a MachineModel is provided in the data dict, it will be used. # Otherwise all-to-all connectivity is assumed. model = None if 'machine_model' in data: model = data['machine_model'] if (not isinstance(model, MachineModel) or model.num_qudits < circuit.get_size()): _logger.warning( 'MachineModel not specified or invalid;' ' defaulting to all-to-all.', ) model = MachineModel(circuit.get_size()) # Find all connected, `block_size`-sized groups of qudits # NOTE: This assumes circuit and topology qudit numbers are equal qudit_groups = model.get_locations(self.block_size) num_cycles = circuit.get_num_cycles() num_qudits_groups = len(qudit_groups) op_cycles = [[[0] * self.block_size for q_group in qudit_groups] for cycle in range(num_cycles)] for cycle, op in circuit.operations_with_cycles(): if len(op.location) > 1: for q_group_index, q_group in enumerate(qudit_groups): if all([qudit in q_group for qudit in op.location]): for qudit in op.location: op_cycles[cycle][q_group_index][q_group.index( qudit)] = self.multi_gate_score else: for qudit in op.location: if qudit in q_group: op_cycles[cycle][q_group_index][q_group.index( qudit)] = -1 else: qudit = op.location[0] for q_group_index, q_group in enumerate(qudit_groups): if qudit in q_group: op_cycles[cycle][q_group_index][q_group.index( qudit)] = self.single_gate_score max_blocks = [] for q_group_index in range(num_qudits_groups): block_start = 0 block_ends = [0] * self.block_size score = 0 for cycle in range(num_cycles): if cycle: for qudit in range(self.block_size): if (op_cycles[cycle - 1][q_group_index][qudit] == -1 and op_cycles[cycle][q_group_index][qudit] != -1): max_blocks.append([ score, block_start, block_ends, q_group_index ], ) score = 0 block_start = cycle block_ends = [cycle + 1] * self.block_size break for qudit in range(self.block_size): if op_cycles[cycle][q_group_index][qudit] != -1: block_ends[qudit] = cycle + 1 score += op_cycles[cycle][q_group_index][qudit] max_blocks.append([score, block_start, block_ends, q_group_index]) block_id = -1 max_blocks.sort() remaining_assignments = circuit.get_size() * num_cycles block_map = [[-1] * circuit.get_size() for cycle in range(num_cycles)] while remaining_assignments: perform_assign = False if len(max_blocks) == 1: perform_assign = True else: block_start = max_blocks[-1][1] block_ends = max_blocks[-1][2] q_group_index = max_blocks[-1][3] score = 0 for cycle in range(block_start, max(block_ends)): for qudit in range(self.block_size): q = qudit_groups[q_group_index][qudit] if (cycle < block_ends[qudit] and block_map[cycle][q] == -1): score += 1 if score < max_blocks[-2][0]: max_blocks[-1][0] = score max_blocks.sort() else: perform_assign = True if perform_assign: block_id += 1 block_start = max_blocks[-1][1] block_ends = max_blocks[-1][2] q_group_index = max_blocks[-1][3] prev_status = None for cycle in range(block_start, max(block_ends)): status = [ block_map[cycle][qudit_groups[q_group_index][qudit]] for qudit in range(self.block_size) ] if prev_status and len(prev_status) <= len( status, ) and status != prev_status: block_id += 1 for qudit in range(self.block_size): if (cycle < block_ends[qudit] and block_map[cycle][ qudit_groups[q_group_index][qudit]] == -1): block_map[cycle][qudit_groups[q_group_index] [qudit]] = block_id remaining_assignments -= 1 prev_status = status del max_blocks[-1] for cycle in range(num_cycles): if not cycle or block_map[cycle] == block_map[cycle - 1]: continue indices = [{}, {}] for i in range(2): for qudit in range(circuit.get_size()): block = block_map[cycle - i][qudit] if block not in indices[i]: indices[i][block] = [] indices[i][block].append(qudit) for prev_blocks, prev_qudits in indices[1].items(): for current_qudits in indices[0].values(): if all([qudit in prev_qudits for qudit in current_qudits]): for qudit in current_qudits: block_map[cycle][qudit] = prev_blocks blocks = {} for cycle in range(num_cycles): for qudit in range(circuit.get_size()): if block_map[cycle][qudit] not in blocks: blocks[block_map[cycle][qudit]] = {} blocks[block_map[cycle][qudit]][-1] = cycle blocks[block_map[cycle][qudit]][qudit] = cycle block_order = [] for block in blocks.values(): block_order.append([block, block[-1]]) block_order.sort(reverse=True, key=lambda x: x[1]) for block, start_cycle in block_order: points_in_block = [] for cycle, op in circuit.operations_with_cycles(): qudit = op.location[0] if (qudit in block and cycle >= start_cycle and cycle <= block[qudit]): points_in_block.append((cycle, qudit)) circuit.fold(circuit.get_region(points_in_block))
def test_invalid_points(self, points: Sequence[CircuitPointLike]) -> None: circuit = Circuit(4, [2, 2, 3, 3]) with pytest.raises(IndexError): circuit.fold(circuit.get_region(points))
def test_type_invalid(self, not_points: Any) -> None: circuit = Circuit(4, [2, 2, 3, 3]) with pytest.raises(TypeError): circuit.fold(not_points)
def test_correctness_1(self) -> None: circuit = Circuit(4) wide_gate = IdentityGate(4) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) circuit.append_gate(wide_gate, [0, 1, 2, 3]) assert circuit.get_num_operations() == 4 assert circuit.get_depth() == 4 utry = circuit.get_unitary() circuit.fold(circuit.get_region([(0, 0), (1, 0)])) assert circuit.get_num_operations() == 3 assert circuit.get_depth() == 3 check_no_idle_cycles(circuit) for q in range(4): assert isinstance(circuit[0, q].gate, CircuitGate) for c in range(1, 3, 1): for q in range(4): assert isinstance(circuit[c, q].gate, IdentityGate) assert isinstance(circuit[c, q].gate, IdentityGate) test_gate: CircuitGate = circuit[0, 0].gate # type: ignore assert test_gate._circuit.get_num_operations() == 2 assert test_gate._circuit.get_num_cycles() == 2 for q in range(4): assert isinstance(test_gate._circuit[0, q].gate, IdentityGate) assert isinstance(test_gate._circuit[1, q].gate, IdentityGate) circuit.fold(circuit.get_region([(1, 0), (2, 0)])) assert circuit.get_num_operations() == 2 assert circuit.get_depth() == 2 check_no_idle_cycles(circuit) for c in range(2): for q in range(4): assert isinstance(circuit[c, q].gate, CircuitGate) test_gate: CircuitGate = circuit[0, 0].gate # type: ignore assert test_gate._circuit.get_num_operations() == 2 assert test_gate._circuit.get_num_cycles() == 2 for q in range(4): assert isinstance(test_gate._circuit[0, q].gate, IdentityGate) assert isinstance(test_gate._circuit[1, q].gate, IdentityGate) test_gate: CircuitGate = circuit[1, 0].gate # type: ignore assert test_gate._circuit.get_num_operations() == 2 assert test_gate._circuit.get_num_cycles() == 2 for q in range(4): assert isinstance(test_gate._circuit[0, q].gate, IdentityGate) assert isinstance(test_gate._circuit[1, q].gate, IdentityGate) circuit.fold(circuit.get_region([(0, 0), (1, 0)])) assert circuit.get_num_operations() == 1 assert circuit.get_depth() == 1 check_no_idle_cycles(circuit) for q in range(4): assert isinstance(circuit[0, q].gate, CircuitGate) test_gate: CircuitGate = circuit[0, 0].gate # type: ignore assert test_gate._circuit.get_num_operations() == 2 assert test_gate._circuit.get_num_cycles() == 2 for q in range(4): assert isinstance(test_gate._circuit[0, q].gate, CircuitGate) assert isinstance(test_gate._circuit[1, q].gate, CircuitGate) inner_gate1: CircuitGate = test_gate._circuit[0, 0].gate # type: ignore inner_gate2: CircuitGate = test_gate._circuit[1, 0].gate # type: ignore assert inner_gate1._circuit.get_num_operations() == 2 assert inner_gate1._circuit.get_num_cycles() == 2 for q in range(4): assert isinstance(inner_gate1._circuit[0, q].gate, IdentityGate) assert isinstance(inner_gate1._circuit[1, q].gate, IdentityGate) assert isinstance(inner_gate2._circuit[0, q].gate, IdentityGate) assert isinstance(inner_gate2._circuit[1, q].gate, IdentityGate) check_no_idle_cycles(circuit) assert np.allclose(utry.get_numpy(), circuit.get_unitary().get_numpy())