def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """Perform the pass's operation, see BasePass for more info.""" start = 'left' if self.start_from_left else 'right' _logger.debug(f'Starting scan gate removal from {start}.') target = circuit.get_unitary() circuit_copy = circuit.copy() reverse_iter = not self.start_from_left for cycle, op in circuit.operations_with_cycles(reverse=reverse_iter): if not self.collection_filter(op): _logger.debug(f'Skipping operation {op} at cycle {cycle}.') continue _logger.info(f'Attempting removal of operation at cycle {cycle}.') _logger.debug(f'Operation: {op}') working_copy = circuit_copy.copy() # If removing gates from the left, we need to track index changes. if self.start_from_left: idx_shift = circuit.get_num_cycles() idx_shift -= working_copy.get_num_cycles() cycle -= idx_shift working_copy.pop((cycle, op.location[0])) working_copy.instantiate(target, **self.instantiate_options) if self.cost(working_copy, target) < self.success_threshold: _logger.info('Successfully removed operation.') circuit_copy = working_copy circuit.become(circuit_copy)
def test_random_batch_remove(self) -> None: num_gates = 200 num_q = 10 circ = Circuit(num_q) for _ in range(num_gates): a = randint(0, num_q - 1) b = randint(0, num_q - 1) if a == b: b = (b + 1) % num_q circ.append_gate(CNOTGate(), [a, b]) ScanPartitioner(2).run(circ, {}) points = [] ops = [] for cycle, op in circ.operations_with_cycles(): point = (cycle, op.location[0]) ops.append(Operation(CNOTGate(), op.location)) points.append(point) circ.batch_replace(points, ops) for op in circ: assert isinstance(op.gate, CNOTGate)
def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """Perform the pass's operation, see BasePass for more info.""" _logger.debug('Converting PauliGates to U3Gates.') for cycle, op in circuit.operations_with_cycles(): if isinstance(op.gate, PauliGate) and len(op.location, ) == 1: # Convert to SU(2) unitary = op.get_unitary().get_numpy() mag = np.linalg.det(unitary)**(-1 / 2) special_unitary = mag * unitary a = np.angle(special_unitary[1, 1]) b = np.angle(special_unitary[1, 0]) # Get angles theta = float( np.arctan2( np.abs(special_unitary[1, 0]), np.abs(special_unitary[0, 0]), ), ) * 2 phi = (a + b) lamb = (a - b) # Replace point = CircuitPoint(cycle, op.location[0]) circuit.replace_gate( point, U3Gate(), op.location, [theta, phi, lamb], )
def run(self, circuit: Circuit, data: dict[str, Any]) -> None: """Perform the pass's operation, see BasePass for more info.""" # Collect CircuitGate blocks blocks: list[tuple[CircuitPoint, Operation]] = [] for cycle, op in circuit.operations_with_cycles(): if isinstance(op.gate, CircuitGate): blocks.append((cycle, op)) # 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()) subdata = data.copy() # Perform work points: list[CircuitPoint] = [] ops: list[Operation] = [] for cycle, op in blocks: gate: CircuitGate = op.gate subcircuit = gate._circuit.copy() subcircuit.set_params(op.params) subnumbering = {op.location[i]: i for i in range(len(op.location))} subdata['machine_model'] = MachineModel( len(op.location), model.get_subgraph(op.location, subnumbering), ) for loop_pass in self.loop_body: loop_pass.run(circuit, subdata) if self.replace_filter(subcircuit, op): points.append(CircuitPoint(cycle, op.location[0])) ops.append( Operation( CircuitGate(subcircuit, True), op.location, subcircuit.get_params(), ), ) # TODO: Load freshly written data from subdata into data circuit.batch_replace(points, ops)
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 run(self, circuit: Circuit, data: dict[str, Any]) -> None: """Perform the pass's operation, see BasePass for more info.""" # Collect synthesizable operations ops_to_syn: list[tuple[int, Operation]] = [] for cycle, op in circuit.operations_with_cycles(): if self.collection_filter(op): ops_to_syn.append((cycle, op)) # 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()) sub_data = data.copy() structure_list: list[Sequence[int]] = [] # Synthesize operations errors: list[float] = [] points: list[CircuitPoint] = [] new_ops: list[Operation] = [] num_blocks = len(ops_to_syn) for block_num, (cycle, op) in enumerate(ops_to_syn): sub_numbering = {op.location[i]: i for i in range(op.size)} sub_data['machine_model'] = MachineModel( len(op.location), model.get_subgraph(op.location, sub_numbering), ) structure_list.append([op.location[i] for i in range(op.size)]) syn_circuit = self.synthesize(op.get_unitary(), sub_data) if self.checkpoint_dir is not None: save_checkpoint(syn_circuit, self.checkpoint_dir, block_num) if self.replace_filter(syn_circuit, op): # Calculate errors new_utry = syn_circuit.get_unitary() old_utry = op.get_unitary() error = new_utry.get_distance_from(old_utry) errors.append(error) points.append(CircuitPoint(cycle, op.location[0])) new_ops.append( Operation( CircuitGate(syn_circuit, True), op.location, list(syn_circuit.get_params()), # TODO: RealVector ), ) _logger.info( f'Error in synthesized CircuitGate {block_num+1} of ' f'{num_blocks}: {error}', ) data['synthesispass_error_sum'] = sum(errors) # TODO: Might be replaced _logger.info( 'Synthesis pass completed. Upper bound on ' f"circuit error is {data['synthesispass_error_sum']}", ) if self.checkpoint_dir is not None: with open(f'{self.checkpoint_dir}/structure.pickle', 'wb') as f: dump(structure_list, f) circuit.batch_replace(points, new_ops)